		Search-engine friendly clone of the ACL2 documentation.

*pdf-grammar-rules*

pdf-grammar-rules-tree-operations

Tree operations specialized to *pdf-grammar-rules*.

Definitions and Theorems

Function: pdf-cst-matchp$

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

Theorem: booleanp-of-pdf-cst-matchp$

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

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

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

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

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

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

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

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

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

Function: pdf-cst-list-elem-matchp$

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

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

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

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

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

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

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

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

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

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

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

Function: pdf-cst-list-rep-matchp$

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Function: pdf-cst-%x20-21-nat

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

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

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

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

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

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

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

Function: pdf-cst-%x20-7e-nat

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

Theorem: natp-of-pdf-cst-%x20-7e-nat

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

Theorem: pdf-cst-%x20-7e-nat-of-tree-fix-cst

(defthm pdf-cst-%x20-7e-nat-of-tree-fix-cst
  (equal (pdf-cst-%x20-7e-nat (tree-fix cst))
         (pdf-cst-%x20-7e-nat cst)))

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

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

Function: pdf-cst-%x23-5b-nat

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

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

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

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

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

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

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

Function: pdf-cst-%x30-39-nat

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

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

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

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

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

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

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

Function: pdf-cst-%x31-39-nat

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

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

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

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

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

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

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

Function: pdf-cst-%x5d-10ffff-nat

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

Theorem: natp-of-pdf-cst-%x5d-10ffff-nat

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

Theorem: pdf-cst-%x5d-10ffff-nat-of-tree-fix-cst

(defthm pdf-cst-%x5d-10ffff-nat-of-tree-fix-cst
  (equal (pdf-cst-%x5d-10ffff-nat (tree-fix cst))
         (pdf-cst-%x5d-10ffff-nat cst)))

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

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

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

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

Theorem: pdf-cst-%x20-7e-nat-bounds

(defthm pdf-cst-%x20-7e-nat-bounds
  (implies (pdf-cst-matchp cst "%x20-7E")
           (and (<= 32 (pdf-cst-%x20-7e-nat cst))
                (<= (pdf-cst-%x20-7e-nat cst) 126)))
  :rule-classes :linear)

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

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

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

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

Theorem: pdf-cst-%x31-39-nat-bounds

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

Theorem: pdf-cst-%x5d-10ffff-nat-bounds

(defthm pdf-cst-%x5d-10ffff-nat-bounds
  (implies (pdf-cst-matchp cst "%x5D-10FFFF")
           (and (<= 93 (pdf-cst-%x5d-10ffff-nat cst))
                (<= (pdf-cst-%x5d-10ffff-nat cst)
                    1114111)))
  :rule-classes :linear)

Theorem: pdf-cst-%s"/basefont"-leafterm

(defthm |PDF-CST-%s"/BaseFont"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/BaseFont\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/contents"-leafterm

(defthm |PDF-CST-%s"/Contents"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Contents\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/count"-leafterm

(defthm |PDF-CST-%s"/Count"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Count\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/encoding"-leafterm

(defthm |PDF-CST-%s"/Encoding"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Encoding\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/font"-leafterm

(defthm |PDF-CST-%s"/Font"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Font\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/id"-leafterm

(defthm |PDF-CST-%s"/ID"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/ID\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/info"-leafterm

(defthm |PDF-CST-%s"/Info"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Info\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/kids"-leafterm

(defthm |PDF-CST-%s"/Kids"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Kids\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/length"-leafterm

(defthm |PDF-CST-%s"/Length"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Length\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/mediabox"-leafterm

(defthm |PDF-CST-%s"/MediaBox"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/MediaBox\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/pages"-leafterm

(defthm |PDF-CST-%s"/Pages"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Pages\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/parent"-leafterm

(defthm |PDF-CST-%s"/Parent"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Parent\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/resources"-leafterm

(defthm |PDF-CST-%s"/Resources"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Resources\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/root"-leafterm

(defthm |PDF-CST-%s"/Root"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Root\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/size"-leafterm

(defthm |PDF-CST-%s"/Size"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Size\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/subtype"-leafterm

(defthm |PDF-CST-%s"/Subtype"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Subtype\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"/type"-leafterm

(defthm |PDF-CST-%s"/Type"-LEAFTERM|
  (implies (pdf-cst-matchp cst "%s\"/Type\"")
           (equal (tree-kind cst) :leafterm)))

Theorem: pdf-cst-%s"cropbox"-leafterm

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

Theorem: pdf-cst-%s"false"-leafterm

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

Theorem: pdf-cst-%s"null"-leafterm

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

Theorem: pdf-cst-%s"true"-leafterm

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

Theorem: pdf-cst-pdf-nonleaf

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

Theorem: pdf-cst-header-nonleaf

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

Theorem: pdf-cst-pdf-marker-nonleaf

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

Theorem: pdf-cst-objects-nonleaf

(defthm pdf-cst-objects-nonleaf
  (implies (pdf-cst-matchp cst "objects")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-object-nonleaf

(defthm pdf-cst-object-nonleaf
  (implies (pdf-cst-matchp cst "object")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-obj-marker-nonleaf

(defthm pdf-cst-obj-marker-nonleaf
  (implies (pdf-cst-matchp cst "obj-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-endobj-marker-nonleaf

(defthm pdf-cst-endobj-marker-nonleaf
  (implies (pdf-cst-matchp cst "endobj-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-stream-nonleaf

(defthm pdf-cst-stream-nonleaf
  (implies (pdf-cst-matchp cst "stream")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-stream-marker-nonleaf

(defthm pdf-cst-stream-marker-nonleaf
  (implies (pdf-cst-matchp cst "stream-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-endstream-marker-nonleaf

(defthm pdf-cst-endstream-marker-nonleaf
  (implies (pdf-cst-matchp cst "endstream-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-xref-nonleaf

(defthm pdf-cst-xref-nonleaf
  (implies (pdf-cst-matchp cst "xref")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-xref-entry-nonleaf

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

Theorem: pdf-cst-use-marker-nonleaf

(defthm pdf-cst-use-marker-nonleaf
  (implies (pdf-cst-matchp cst "use-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-xref-marker-nonleaf

(defthm pdf-cst-xref-marker-nonleaf
  (implies (pdf-cst-matchp cst "xref-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-xref-int-nonleaf

(defthm pdf-cst-xref-int-nonleaf
  (implies (pdf-cst-matchp cst "xref-int")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-trailer-nonleaf

(defthm pdf-cst-trailer-nonleaf
  (implies (pdf-cst-matchp cst "trailer")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-startxref-marker-nonleaf

(defthm pdf-cst-startxref-marker-nonleaf
  (implies (pdf-cst-matchp cst "startxref-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-eof-marker-nonleaf

(defthm pdf-cst-eof-marker-nonleaf
  (implies (pdf-cst-matchp cst "eof-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-trailer-dictionary-nonleaf

(defthm pdf-cst-trailer-dictionary-nonleaf
  (implies (pdf-cst-matchp cst "trailer-dictionary")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-trailer-key-and-value-nonleaf

(defthm pdf-cst-trailer-key-and-value-nonleaf
  (implies (pdf-cst-matchp cst "trailer-key-and-value")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-trailer-marker-nonleaf

(defthm pdf-cst-trailer-marker-nonleaf
  (implies (pdf-cst-matchp cst "trailer-marker")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-dictionary-nonleaf

(defthm pdf-cst-dictionary-nonleaf
  (implies (pdf-cst-matchp cst "dictionary")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-dict-entry-nonleaf

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

Theorem: pdf-cst-default-entry-nonleaf

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

Theorem: pdf-cst-type-entry-nonleaf

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

Theorem: pdf-cst-reference-entry-nonleaf

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

Theorem: pdf-cst-reference-array-entry-nonleaf

(defthm pdf-cst-reference-array-entry-nonleaf
  (implies (pdf-cst-matchp cst "reference-array-entry")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-rectangle-entry-nonleaf

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

Theorem: pdf-cst-number-entry-nonleaf

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

Theorem: pdf-cst-name-entry-nonleaf

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

Theorem: pdf-cst-font-entry-nonleaf

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

Theorem: pdf-cst-font-nonleaf

(defthm pdf-cst-font-nonleaf
  (implies (pdf-cst-matchp cst "font")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-dict-key-nonleaf

(defthm pdf-cst-dict-key-nonleaf
  (implies (pdf-cst-matchp cst "dict-key")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-dict-value-nonleaf

(defthm pdf-cst-dict-value-nonleaf
  (implies (pdf-cst-matchp cst "dict-value")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-start-dict-nonleaf

(defthm pdf-cst-start-dict-nonleaf
  (implies (pdf-cst-matchp cst "start-dict")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-end-dict-nonleaf

(defthm pdf-cst-end-dict-nonleaf
  (implies (pdf-cst-matchp cst "end-dict")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-ws-nonleaf

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

Theorem: pdf-cst-digit1-9-nonleaf

(defthm pdf-cst-digit1-9-nonleaf
  (implies (pdf-cst-matchp cst "digit1-9")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-digit-nonleaf

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

Theorem: pdf-cst-boolean-nonleaf

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

Theorem: pdf-cst-array-nonleaf

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

Theorem: pdf-cst-reference-array-nonleaf

(defthm pdf-cst-reference-array-nonleaf
  (implies (pdf-cst-matchp cst "reference-array")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-reference-nonleaf

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

Theorem: pdf-cst-rectangle-nonleaf

(defthm pdf-cst-rectangle-nonleaf
  (implies (pdf-cst-matchp cst "rectangle")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-left-bracket-nonleaf

(defthm pdf-cst-left-bracket-nonleaf
  (implies (pdf-cst-matchp cst "left-bracket")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-right-bracket-nonleaf

(defthm pdf-cst-right-bracket-nonleaf
  (implies (pdf-cst-matchp cst "right-bracket")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-number-nonleaf

(defthm pdf-cst-number-nonleaf
  (implies (pdf-cst-matchp cst "number")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-null-nonleaf

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

Theorem: pdf-cst-name-nonleaf

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

Theorem: pdf-cst-name-char-nonleaf

(defthm pdf-cst-name-char-nonleaf
  (implies (pdf-cst-matchp cst "name-char")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-real-nonleaf

(defthm pdf-cst-real-nonleaf
  (implies (pdf-cst-matchp cst "real")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-int-nonleaf

(defthm pdf-cst-int-nonleaf
  (implies (pdf-cst-matchp cst "int")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-plus-nonleaf

(defthm pdf-cst-plus-nonleaf
  (implies (pdf-cst-matchp cst "plus")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-minus-nonleaf

(defthm pdf-cst-minus-nonleaf
  (implies (pdf-cst-matchp cst "minus")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-slash-nonleaf

(defthm pdf-cst-slash-nonleaf
  (implies (pdf-cst-matchp cst "slash")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-backslash-nonleaf

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

Theorem: pdf-cst-zero-nonleaf

(defthm pdf-cst-zero-nonleaf
  (implies (pdf-cst-matchp cst "zero")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-string-nonleaf

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

Theorem: pdf-cst-period-nonleaf

(defthm pdf-cst-period-nonleaf
  (implies (pdf-cst-matchp cst "period")
           (equal (tree-kind cst) :nonleaf)))

Theorem: pdf-cst-char-nonleaf

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

Theorem: pdf-cst-pdf-rulename

(defthm pdf-cst-pdf-rulename
  (implies (pdf-cst-matchp cst "pdf")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "pdf"))))

Theorem: pdf-cst-header-rulename

(defthm pdf-cst-header-rulename
  (implies (pdf-cst-matchp cst "header")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "header"))))

Theorem: pdf-cst-pdf-marker-rulename

(defthm pdf-cst-pdf-marker-rulename
  (implies (pdf-cst-matchp cst "pdf-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "pdf-marker"))))

Theorem: pdf-cst-objects-rulename

(defthm pdf-cst-objects-rulename
  (implies (pdf-cst-matchp cst "objects")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "objects"))))

Theorem: pdf-cst-object-rulename

(defthm pdf-cst-object-rulename
  (implies (pdf-cst-matchp cst "object")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "object"))))

Theorem: pdf-cst-obj-marker-rulename

(defthm pdf-cst-obj-marker-rulename
  (implies (pdf-cst-matchp cst "obj-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "obj-marker"))))

Theorem: pdf-cst-endobj-marker-rulename

(defthm pdf-cst-endobj-marker-rulename
  (implies (pdf-cst-matchp cst "endobj-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "endobj-marker"))))

Theorem: pdf-cst-stream-rulename

(defthm pdf-cst-stream-rulename
  (implies (pdf-cst-matchp cst "stream")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "stream"))))

Theorem: pdf-cst-stream-marker-rulename

(defthm pdf-cst-stream-marker-rulename
  (implies (pdf-cst-matchp cst "stream-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "stream-marker"))))

Theorem: pdf-cst-endstream-marker-rulename

(defthm pdf-cst-endstream-marker-rulename
  (implies (pdf-cst-matchp cst "endstream-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "endstream-marker"))))

Theorem: pdf-cst-xref-rulename

(defthm pdf-cst-xref-rulename
  (implies (pdf-cst-matchp cst "xref")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "xref"))))

Theorem: pdf-cst-xref-entry-rulename

(defthm pdf-cst-xref-entry-rulename
  (implies (pdf-cst-matchp cst "xref-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "xref-entry"))))

Theorem: pdf-cst-use-marker-rulename

(defthm pdf-cst-use-marker-rulename
  (implies (pdf-cst-matchp cst "use-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "use-marker"))))

Theorem: pdf-cst-xref-marker-rulename

(defthm pdf-cst-xref-marker-rulename
  (implies (pdf-cst-matchp cst "xref-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "xref-marker"))))

Theorem: pdf-cst-xref-int-rulename

(defthm pdf-cst-xref-int-rulename
  (implies (pdf-cst-matchp cst "xref-int")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "xref-int"))))

Theorem: pdf-cst-trailer-rulename

(defthm pdf-cst-trailer-rulename
  (implies (pdf-cst-matchp cst "trailer")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "trailer"))))

Theorem: pdf-cst-startxref-marker-rulename

(defthm pdf-cst-startxref-marker-rulename
  (implies (pdf-cst-matchp cst "startxref-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "startxref-marker"))))

Theorem: pdf-cst-eof-marker-rulename

(defthm pdf-cst-eof-marker-rulename
  (implies (pdf-cst-matchp cst "eof-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "eof-marker"))))

Theorem: pdf-cst-trailer-dictionary-rulename

(defthm pdf-cst-trailer-dictionary-rulename
  (implies (pdf-cst-matchp cst "trailer-dictionary")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "trailer-dictionary"))))

Theorem: pdf-cst-trailer-key-and-value-rulename

(defthm pdf-cst-trailer-key-and-value-rulename
  (implies (pdf-cst-matchp cst "trailer-key-and-value")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "trailer-key-and-value"))))

Theorem: pdf-cst-trailer-marker-rulename

(defthm pdf-cst-trailer-marker-rulename
  (implies (pdf-cst-matchp cst "trailer-marker")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "trailer-marker"))))

Theorem: pdf-cst-dictionary-rulename

(defthm pdf-cst-dictionary-rulename
  (implies (pdf-cst-matchp cst "dictionary")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dictionary"))))

Theorem: pdf-cst-dict-entry-rulename

(defthm pdf-cst-dict-entry-rulename
  (implies (pdf-cst-matchp cst "dict-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dict-entry"))))

Theorem: pdf-cst-default-entry-rulename

(defthm pdf-cst-default-entry-rulename
  (implies (pdf-cst-matchp cst "default-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "default-entry"))))

Theorem: pdf-cst-type-entry-rulename

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

Theorem: pdf-cst-reference-entry-rulename

(defthm pdf-cst-reference-entry-rulename
  (implies (pdf-cst-matchp cst "reference-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reference-entry"))))

Theorem: pdf-cst-reference-array-entry-rulename

(defthm pdf-cst-reference-array-entry-rulename
  (implies (pdf-cst-matchp cst "reference-array-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reference-array-entry"))))

Theorem: pdf-cst-rectangle-entry-rulename

(defthm pdf-cst-rectangle-entry-rulename
  (implies (pdf-cst-matchp cst "rectangle-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "rectangle-entry"))))

Theorem: pdf-cst-number-entry-rulename

(defthm pdf-cst-number-entry-rulename
  (implies (pdf-cst-matchp cst "number-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "number-entry"))))

Theorem: pdf-cst-name-entry-rulename

(defthm pdf-cst-name-entry-rulename
  (implies (pdf-cst-matchp cst "name-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "name-entry"))))

Theorem: pdf-cst-font-entry-rulename

(defthm pdf-cst-font-entry-rulename
  (implies (pdf-cst-matchp cst "font-entry")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "font-entry"))))

Theorem: pdf-cst-font-rulename

(defthm pdf-cst-font-rulename
  (implies (pdf-cst-matchp cst "font")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "font"))))

Theorem: pdf-cst-dict-key-rulename

(defthm pdf-cst-dict-key-rulename
  (implies (pdf-cst-matchp cst "dict-key")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dict-key"))))

Theorem: pdf-cst-dict-value-rulename

(defthm pdf-cst-dict-value-rulename
  (implies (pdf-cst-matchp cst "dict-value")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "dict-value"))))

Theorem: pdf-cst-start-dict-rulename

(defthm pdf-cst-start-dict-rulename
  (implies (pdf-cst-matchp cst "start-dict")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "start-dict"))))

Theorem: pdf-cst-end-dict-rulename

(defthm pdf-cst-end-dict-rulename
  (implies (pdf-cst-matchp cst "end-dict")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "end-dict"))))

Theorem: pdf-cst-ws-rulename

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

Theorem: pdf-cst-digit1-9-rulename

(defthm pdf-cst-digit1-9-rulename
  (implies (pdf-cst-matchp cst "digit1-9")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "digit1-9"))))

Theorem: pdf-cst-digit-rulename

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

Theorem: pdf-cst-boolean-rulename

(defthm pdf-cst-boolean-rulename
  (implies (pdf-cst-matchp cst "boolean")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "boolean"))))

Theorem: pdf-cst-array-rulename

(defthm pdf-cst-array-rulename
  (implies (pdf-cst-matchp cst "array")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "array"))))

Theorem: pdf-cst-reference-array-rulename

(defthm pdf-cst-reference-array-rulename
  (implies (pdf-cst-matchp cst "reference-array")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reference-array"))))

Theorem: pdf-cst-reference-rulename

(defthm pdf-cst-reference-rulename
  (implies (pdf-cst-matchp cst "reference")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "reference"))))

Theorem: pdf-cst-rectangle-rulename

(defthm pdf-cst-rectangle-rulename
  (implies (pdf-cst-matchp cst "rectangle")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "rectangle"))))

Theorem: pdf-cst-left-bracket-rulename

(defthm pdf-cst-left-bracket-rulename
  (implies (pdf-cst-matchp cst "left-bracket")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "left-bracket"))))

Theorem: pdf-cst-right-bracket-rulename

(defthm pdf-cst-right-bracket-rulename
  (implies (pdf-cst-matchp cst "right-bracket")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "right-bracket"))))

Theorem: pdf-cst-number-rulename

(defthm pdf-cst-number-rulename
  (implies (pdf-cst-matchp cst "number")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "number"))))

Theorem: pdf-cst-null-rulename

(defthm pdf-cst-null-rulename
  (implies (pdf-cst-matchp cst "null")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "null"))))

Theorem: pdf-cst-name-rulename

(defthm pdf-cst-name-rulename
  (implies (pdf-cst-matchp cst "name")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "name"))))

Theorem: pdf-cst-name-char-rulename

(defthm pdf-cst-name-char-rulename
  (implies (pdf-cst-matchp cst "name-char")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "name-char"))))

Theorem: pdf-cst-real-rulename

(defthm pdf-cst-real-rulename
  (implies (pdf-cst-matchp cst "real")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "real"))))

Theorem: pdf-cst-int-rulename

(defthm pdf-cst-int-rulename
  (implies (pdf-cst-matchp cst "int")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "int"))))

Theorem: pdf-cst-plus-rulename

(defthm pdf-cst-plus-rulename
  (implies (pdf-cst-matchp cst "plus")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "plus"))))

Theorem: pdf-cst-minus-rulename

(defthm pdf-cst-minus-rulename
  (implies (pdf-cst-matchp cst "minus")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "minus"))))

Theorem: pdf-cst-slash-rulename

(defthm pdf-cst-slash-rulename
  (implies (pdf-cst-matchp cst "slash")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "slash"))))

Theorem: pdf-cst-backslash-rulename

(defthm pdf-cst-backslash-rulename
  (implies (pdf-cst-matchp cst "backslash")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "backslash"))))

Theorem: pdf-cst-zero-rulename

(defthm pdf-cst-zero-rulename
  (implies (pdf-cst-matchp cst "zero")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "zero"))))

Theorem: pdf-cst-string-rulename

(defthm pdf-cst-string-rulename
  (implies (pdf-cst-matchp cst "string")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "string"))))

Theorem: pdf-cst-period-rulename

(defthm pdf-cst-period-rulename
  (implies (pdf-cst-matchp cst "period")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "period"))))

Theorem: pdf-cst-char-rulename

(defthm pdf-cst-char-rulename
  (implies (pdf-cst-matchp cst "char")
           (equal (tree-nonleaf->rulename? cst)
                  (rulename "char"))))

Theorem: pdf-cst-pdf-branches-match-alt

(defthm pdf-cst-pdf-branches-match-alt
 (implies
      (pdf-cst-matchp cst "pdf")
      (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                    "header objects xref trailer")))

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

(defthm pdf-cst-header-branches-match-alt
 (implies
     (pdf-cst-matchp cst "header")
     (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                   "pdf-marker int period int ws")))

Theorem: pdf-cst-pdf-marker-branches-match-alt

(defthm pdf-cst-pdf-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "pdf-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x25.50.44.46.45")))

Theorem: pdf-cst-objects-branches-match-alt

(defthm pdf-cst-objects-branches-match-alt
 (implies (pdf-cst-matchp cst "objects")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "*object")))

Theorem: pdf-cst-object-branches-match-alt

(defthm pdf-cst-object-branches-match-alt
 (implies
  (pdf-cst-matchp cst "object")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker")))

Theorem: pdf-cst-obj-marker-branches-match-alt

(defthm pdf-cst-obj-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "obj-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x6F.62.6A")))

Theorem: pdf-cst-endobj-marker-branches-match-alt

(defthm pdf-cst-endobj-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "endobj-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x65.6E.64.6F.62.6A")))

Theorem: pdf-cst-stream-branches-match-alt

(defthm pdf-cst-stream-branches-match-alt
  (implies (pdf-cst-matchp cst "stream")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "stream-marker *char endstream-marker")))

Theorem: pdf-cst-stream-marker-branches-match-alt

(defthm pdf-cst-stream-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "stream-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x73.74.72.65.61.6D")))

Theorem: pdf-cst-endstream-marker-branches-match-alt

(defthm pdf-cst-endstream-marker-branches-match-alt
 (implies
     (pdf-cst-matchp cst "endstream-marker")
     (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                   "%x65.6E.64.73.74.72.65.61.6D")))

Theorem: pdf-cst-xref-branches-match-alt

(defthm pdf-cst-xref-branches-match-alt
  (implies (pdf-cst-matchp cst "xref")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "xref-marker ws zero ws int ws *xref-entry")))

Theorem: pdf-cst-xref-entry-branches-match-alt

(defthm pdf-cst-xref-entry-branches-match-alt
  (implies (pdf-cst-matchp cst "xref-entry")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "xref-int ws xref-int ws use-marker")))

Theorem: pdf-cst-use-marker-branches-match-alt

(defthm pdf-cst-use-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "use-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x6E / %x66")))

Theorem: pdf-cst-xref-marker-branches-match-alt

(defthm pdf-cst-xref-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "xref-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x78.72.65.66")))

Theorem: pdf-cst-xref-int-branches-match-alt

(defthm pdf-cst-xref-int-branches-match-alt
 (implies (pdf-cst-matchp cst "xref-int")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "*digit")))

Theorem: pdf-cst-trailer-branches-match-alt

(defthm pdf-cst-trailer-branches-match-alt
 (implies
  (pdf-cst-matchp cst "trailer")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "trailer-marker ws dictionary ws startxref-marker ws int eof-marker")))

Theorem: pdf-cst-startxref-marker-branches-match-alt

(defthm pdf-cst-startxref-marker-branches-match-alt
 (implies
     (pdf-cst-matchp cst "startxref-marker")
     (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                   "%x73.74.61.72.74.78.72.65.66")))

Theorem: pdf-cst-eof-marker-branches-match-alt

(defthm pdf-cst-eof-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "eof-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x25.25.45.4F.46")))

Theorem: pdf-cst-trailer-dictionary-branches-match-alt

(defthm pdf-cst-trailer-dictionary-branches-match-alt
  (implies (pdf-cst-matchp cst "trailer-dictionary")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "start-dict *trailer-key-and-value end-dict")))

Theorem: pdf-cst-trailer-key-and-value-branches-match-alt

(defthm pdf-cst-trailer-key-and-value-branches-match-alt
 (implies
  (pdf-cst-matchp cst "trailer-key-and-value")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "( %s\"/Size\" int ) / ( %s\"/Root\" reference ) / ( %s\"/Info\" reference ) / ( %s\"/ID\" left-bracket string string right-bracket )")))

Theorem: pdf-cst-trailer-marker-branches-match-alt

(defthm pdf-cst-trailer-marker-branches-match-alt
 (implies (pdf-cst-matchp cst "trailer-marker")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x74.72.61.69.6C.65.72")))

Theorem: pdf-cst-dictionary-branches-match-alt

(defthm pdf-cst-dictionary-branches-match-alt
 (implies
  (pdf-cst-matchp cst "dictionary")
  (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                "start-dict *dict-entry end-dict")))

Theorem: pdf-cst-dict-entry-branches-match-alt

(defthm pdf-cst-dict-entry-branches-match-alt
 (implies
  (pdf-cst-matchp cst "dict-entry")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "type-entry / reference-entry / reference-array-entry / rectangle-entry / number-entry / name-entry / font-entry / default-entry")))

Theorem: pdf-cst-default-entry-branches-match-alt

(defthm pdf-cst-default-entry-branches-match-alt
 (implies (pdf-cst-matchp cst "default-entry")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "dict-key ws dict-value")))

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

(defthm pdf-cst-type-entry-branches-match-alt
 (implies (pdf-cst-matchp cst "type-entry")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%s\"/Type\" name")))

Theorem: pdf-cst-reference-entry-branches-match-alt

(defthm pdf-cst-reference-entry-branches-match-alt
 (implies
  (pdf-cst-matchp cst "reference-entry")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "%s\"/Parent\" / %s\"/Pages\" / %s\"/Contents\" / %s\"/Resources\" reference")))

Theorem: pdf-cst-reference-array-entry-branches-match-alt

(defthm pdf-cst-reference-array-entry-branches-match-alt
  (implies
       (pdf-cst-matchp cst "reference-array-entry")
       (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "%s\"/Kids\" reference-array")))

Theorem: pdf-cst-rectangle-entry-branches-match-alt

(defthm pdf-cst-rectangle-entry-branches-match-alt
  (implies (pdf-cst-matchp cst "rectangle-entry")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "%s\"/MediaBox\" / %s\"CropBox\" rectangle")))

Theorem: pdf-cst-number-entry-branches-match-alt

(defthm pdf-cst-number-entry-branches-match-alt
  (implies (pdf-cst-matchp cst "number-entry")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "( %s\"/Count\" ) / ( %s\"/Length\" ) number")))

Theorem: pdf-cst-name-entry-branches-match-alt

(defthm pdf-cst-name-entry-branches-match-alt
 (implies
  (pdf-cst-matchp cst "name-entry")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "( %s\"/Subtype\" ) / ( %s\"/BaseFont\" ) / ( %s\"/Encoding\" ) name")))

Theorem: pdf-cst-font-entry-branches-match-alt

(defthm pdf-cst-font-entry-branches-match-alt
 (implies (pdf-cst-matchp cst "font-entry")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%s\"/Font\" font")))

Theorem: pdf-cst-font-branches-match-alt

(defthm pdf-cst-font-branches-match-alt
  (implies (pdf-cst-matchp cst "font")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "start-dict name reference end-dict")))

Theorem: pdf-cst-dict-key-branches-match-alt

(defthm pdf-cst-dict-key-branches-match-alt
 (implies (pdf-cst-matchp cst "dict-key")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "backslash *char")))

Theorem: pdf-cst-dict-value-branches-match-alt

(defthm pdf-cst-dict-value-branches-match-alt
 (implies
  (pdf-cst-matchp cst "dict-value")
  (pdf-cst-list-list-alt-matchp
   (tree-nonleaf->branches cst)
   "boolean / number / name / array / dictionary / null / rectangle / reference / string")))

Theorem: pdf-cst-start-dict-branches-match-alt

(defthm pdf-cst-start-dict-branches-match-alt
 (implies (pdf-cst-matchp cst "start-dict")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x3C.3C")))

Theorem: pdf-cst-end-dict-branches-match-alt

(defthm pdf-cst-end-dict-branches-match-alt
 (implies (pdf-cst-matchp cst "end-dict")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x3E.3E")))

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

(defthm pdf-cst-ws-branches-match-alt
  (implies (pdf-cst-matchp cst "ws")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )")))

Theorem: pdf-cst-digit1-9-branches-match-alt

(defthm pdf-cst-digit1-9-branches-match-alt
 (implies (pdf-cst-matchp cst "digit1-9")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x31-39")))

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

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

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

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

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

(defthm pdf-cst-array-branches-match-alt
  (implies (pdf-cst-matchp cst "array")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "left-bracket *char right-bracket")))

Theorem: pdf-cst-reference-array-branches-match-alt

(defthm pdf-cst-reference-array-branches-match-alt
  (implies (pdf-cst-matchp cst "reference-array")
           (pdf-cst-list-list-alt-matchp
                (tree-nonleaf->branches cst)
                "left-bracket *reference right-bracket")))

Theorem: pdf-cst-reference-branches-match-alt

(defthm pdf-cst-reference-branches-match-alt
 (implies (pdf-cst-matchp cst "reference")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "int %x20 zero %x52")))

Theorem: pdf-cst-rectangle-branches-match-alt

(defthm pdf-cst-rectangle-branches-match-alt
 (implies
    (pdf-cst-matchp cst "rectangle")
    (pdf-cst-list-list-alt-matchp
         (tree-nonleaf->branches cst)
         "left-bracket number number number number right-bracket")))

Theorem: pdf-cst-left-bracket-branches-match-alt

(defthm pdf-cst-left-bracket-branches-match-alt
 (implies (pdf-cst-matchp cst "left-bracket")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x5B")))

Theorem: pdf-cst-right-bracket-branches-match-alt

(defthm pdf-cst-right-bracket-branches-match-alt
 (implies (pdf-cst-matchp cst "right-bracket")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x5D")))

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

(defthm pdf-cst-number-branches-match-alt
 (implies
      (pdf-cst-matchp cst "number")
      (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                    "[ plus / minus ] real / int")))

Theorem: pdf-cst-null-branches-match-alt

(defthm pdf-cst-null-branches-match-alt
 (implies (pdf-cst-matchp cst "null")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%s\"null\"")))

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

(defthm pdf-cst-name-branches-match-alt
 (implies (pdf-cst-matchp cst "name")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "slash name-char")))

Theorem: pdf-cst-name-char-branches-match-alt

(defthm pdf-cst-name-char-branches-match-alt
 (implies (pdf-cst-matchp cst "name-char")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x20-7E")))

Theorem: pdf-cst-real-branches-match-alt

(defthm pdf-cst-real-branches-match-alt
 (implies (pdf-cst-matchp cst "real")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "int period int")))

Theorem: pdf-cst-int-branches-match-alt

(defthm pdf-cst-int-branches-match-alt
  (implies
       (pdf-cst-matchp cst "int")
       (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                     "zero / ( digit1-9 *digit )")))

Theorem: pdf-cst-plus-branches-match-alt

(defthm pdf-cst-plus-branches-match-alt
 (implies (pdf-cst-matchp cst "plus")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x2B")))

Theorem: pdf-cst-minus-branches-match-alt

(defthm pdf-cst-minus-branches-match-alt
 (implies (pdf-cst-matchp cst "minus")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x2D")))

Theorem: pdf-cst-slash-branches-match-alt

(defthm pdf-cst-slash-branches-match-alt
 (implies (pdf-cst-matchp cst "slash")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x2F")))

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

(defthm pdf-cst-backslash-branches-match-alt
 (implies (pdf-cst-matchp cst "backslash")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x5C")))

Theorem: pdf-cst-zero-branches-match-alt

(defthm pdf-cst-zero-branches-match-alt
 (implies (pdf-cst-matchp cst "zero")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x30")))

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

(defthm pdf-cst-string-branches-match-alt
 (implies (pdf-cst-matchp cst "string")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "*char")))

Theorem: pdf-cst-period-branches-match-alt

(defthm pdf-cst-period-branches-match-alt
 (implies (pdf-cst-matchp cst "period")
          (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                        "%x2E")))

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

(defthm pdf-cst-char-branches-match-alt
 (implies
  (pdf-cst-matchp cst "char")
  (pdf-cst-list-list-alt-matchp (tree-nonleaf->branches cst)
                                "%x20-21 / %x23-5B / %x5D-10FFFF")))

Theorem: pdf-cst-pdf-concs

(defthm pdf-cst-pdf-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "header objects xref trailer")
  (or (pdf-cst-list-list-conc-matchp
           cstss "header objects xref trailer"))))

Theorem: pdf-cst-header-concs

(defthm pdf-cst-header-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss "pdf-marker int period int ws")
           (or (pdf-cst-list-list-conc-matchp
                    cstss "pdf-marker int period int ws"))))

Theorem: pdf-cst-pdf-marker-concs

(defthm pdf-cst-pdf-marker-concs
 (implies
     (pdf-cst-list-list-alt-matchp cstss "%x25.50.44.46.45")
     (or (pdf-cst-list-list-conc-matchp cstss "%x25.50.44.46.45"))))

Theorem: pdf-cst-objects-concs

(defthm pdf-cst-objects-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "*object")
           (or (pdf-cst-list-list-conc-matchp cstss "*object"))))

Theorem: pdf-cst-object-concs

(defthm pdf-cst-object-concs
 (implies
  (pdf-cst-list-list-alt-matchp
   cstss
   "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker")
  (or
   (pdf-cst-list-list-conc-matchp
    cstss
    "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker"))))

Theorem: pdf-cst-obj-marker-concs

(defthm pdf-cst-obj-marker-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x6F.62.6A")
           (or (pdf-cst-list-list-conc-matchp cstss "%x6F.62.6A"))))

Theorem: pdf-cst-endobj-marker-concs

(defthm pdf-cst-endobj-marker-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "%x65.6E.64.6F.62.6A")
  (or (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.6F.62.6A"))))

Theorem: pdf-cst-stream-concs

(defthm pdf-cst-stream-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "stream-marker *char endstream-marker")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "stream-marker *char endstream-marker"))))

Theorem: pdf-cst-stream-marker-concs

(defthm pdf-cst-stream-marker-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "%x73.74.72.65.61.6D")
  (or (pdf-cst-list-list-conc-matchp cstss "%x73.74.72.65.61.6D"))))

Theorem: pdf-cst-endstream-marker-concs

(defthm pdf-cst-endstream-marker-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss "%x65.6E.64.73.74.72.65.61.6D")
           (or (pdf-cst-list-list-conc-matchp
                    cstss "%x65.6E.64.73.74.72.65.61.6D"))))

Theorem: pdf-cst-xref-concs

(defthm pdf-cst-xref-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "xref-marker ws zero ws int ws *xref-entry")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "xref-marker ws zero ws int ws *xref-entry"))))

Theorem: pdf-cst-xref-entry-concs

(defthm pdf-cst-xref-entry-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "xref-int ws xref-int ws use-marker")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "xref-int ws xref-int ws use-marker"))))

Theorem: pdf-cst-use-marker-concs

(defthm pdf-cst-use-marker-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x6E / %x66")
           (or (pdf-cst-list-list-conc-matchp cstss "%x6E")
               (pdf-cst-list-list-conc-matchp cstss "%x66"))))

Theorem: pdf-cst-xref-marker-concs

(defthm pdf-cst-xref-marker-concs
  (implies
       (pdf-cst-list-list-alt-matchp cstss "%x78.72.65.66")
       (or (pdf-cst-list-list-conc-matchp cstss "%x78.72.65.66"))))

Theorem: pdf-cst-xref-int-concs

(defthm pdf-cst-xref-int-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "*digit")
           (or (pdf-cst-list-list-conc-matchp cstss "*digit"))))

Theorem: pdf-cst-trailer-concs

(defthm pdf-cst-trailer-concs
 (implies
  (pdf-cst-list-list-alt-matchp
   cstss
   "trailer-marker ws dictionary ws startxref-marker ws int eof-marker")
  (or
   (pdf-cst-list-list-conc-matchp
    cstss
    "trailer-marker ws dictionary ws startxref-marker ws int eof-marker"))))

Theorem: pdf-cst-startxref-marker-concs

(defthm pdf-cst-startxref-marker-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss "%x73.74.61.72.74.78.72.65.66")
           (or (pdf-cst-list-list-conc-matchp
                    cstss "%x73.74.61.72.74.78.72.65.66"))))

Theorem: pdf-cst-eof-marker-concs

(defthm pdf-cst-eof-marker-concs
 (implies
     (pdf-cst-list-list-alt-matchp cstss "%x25.25.45.4F.46")
     (or (pdf-cst-list-list-conc-matchp cstss "%x25.25.45.4F.46"))))

Theorem: pdf-cst-trailer-dictionary-concs

(defthm pdf-cst-trailer-dictionary-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "start-dict *trailer-key-and-value end-dict")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "start-dict *trailer-key-and-value end-dict"))))

Theorem: pdf-cst-trailer-key-and-value-concs

(defthm pdf-cst-trailer-key-and-value-concs
 (implies
  (pdf-cst-list-list-alt-matchp
   cstss
   "( %s\"/Size\" int ) / ( %s\"/Root\" reference ) / ( %s\"/Info\" reference ) / ( %s\"/ID\" left-bracket string string right-bracket )")
  (or
     (pdf-cst-list-list-conc-matchp cstss "( %s\"/Size\" int )")
     (pdf-cst-list-list-conc-matchp cstss "( %s\"/Root\" reference )")
     (pdf-cst-list-list-conc-matchp cstss "( %s\"/Info\" reference )")
     (pdf-cst-list-list-conc-matchp
          cstss
          "( %s\"/ID\" left-bracket string string right-bracket )"))))

Theorem: pdf-cst-trailer-marker-concs

(defthm pdf-cst-trailer-marker-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "%x74.72.61.69.6C.65.72")
  (or
   (pdf-cst-list-list-conc-matchp cstss "%x74.72.61.69.6C.65.72"))))

Theorem: pdf-cst-dictionary-concs

(defthm pdf-cst-dictionary-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss "start-dict *dict-entry end-dict")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "start-dict *dict-entry end-dict"))))

Theorem: pdf-cst-dict-entry-concs

(defthm pdf-cst-dict-entry-concs
 (implies
  (pdf-cst-list-list-alt-matchp
   cstss
   "type-entry / reference-entry / reference-array-entry / rectangle-entry / number-entry / name-entry / font-entry / default-entry")
  (or (pdf-cst-list-list-conc-matchp cstss "type-entry")
      (pdf-cst-list-list-conc-matchp cstss "reference-entry")
      (pdf-cst-list-list-conc-matchp cstss "reference-array-entry")
      (pdf-cst-list-list-conc-matchp cstss "rectangle-entry")
      (pdf-cst-list-list-conc-matchp cstss "number-entry")
      (pdf-cst-list-list-conc-matchp cstss "name-entry")
      (pdf-cst-list-list-conc-matchp cstss "font-entry")
      (pdf-cst-list-list-conc-matchp cstss "default-entry"))))

Theorem: pdf-cst-default-entry-concs

(defthm pdf-cst-default-entry-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "dict-key ws dict-value")
  (or
   (pdf-cst-list-list-conc-matchp cstss "dict-key ws dict-value"))))

Theorem: pdf-cst-type-entry-concs

(defthm pdf-cst-type-entry-concs
  (implies
       (pdf-cst-list-list-alt-matchp cstss "%s\"/Type\" name")
       (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Type\" name"))))

Theorem: pdf-cst-reference-entry-concs

(defthm pdf-cst-reference-entry-concs
 (implies
  (pdf-cst-list-list-alt-matchp
   cstss
   "%s\"/Parent\" / %s\"/Pages\" / %s\"/Contents\" / %s\"/Resources\" reference")
  (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Parent\"")
      (pdf-cst-list-list-conc-matchp cstss "%s\"/Pages\"")
      (pdf-cst-list-list-conc-matchp cstss "%s\"/Contents\"")
      (pdf-cst-list-list-conc-matchp
           cstss "%s\"/Resources\" reference"))))

Theorem: pdf-cst-reference-array-entry-concs

(defthm pdf-cst-reference-array-entry-concs
 (implies
    (pdf-cst-list-list-alt-matchp cstss "%s\"/Kids\" reference-array")
    (or (pdf-cst-list-list-conc-matchp
             cstss "%s\"/Kids\" reference-array"))))

Theorem: pdf-cst-rectangle-entry-concs

(defthm pdf-cst-rectangle-entry-concs
 (implies
  (pdf-cst-list-list-alt-matchp
       cstss
       "%s\"/MediaBox\" / %s\"CropBox\" rectangle")
  (or
    (pdf-cst-list-list-conc-matchp cstss "%s\"/MediaBox\"")
    (pdf-cst-list-list-conc-matchp cstss "%s\"CropBox\" rectangle"))))

Theorem: pdf-cst-number-entry-concs

(defthm pdf-cst-number-entry-concs
 (implies
  (pdf-cst-list-list-alt-matchp
       cstss
       "( %s\"/Count\" ) / ( %s\"/Length\" ) number")
  (or
   (pdf-cst-list-list-conc-matchp cstss "( %s\"/Count\" )")
   (pdf-cst-list-list-conc-matchp cstss "( %s\"/Length\" ) number"))))

Theorem: pdf-cst-name-entry-concs

(defthm pdf-cst-name-entry-concs
 (implies
  (pdf-cst-list-list-alt-matchp
    cstss
    "( %s\"/Subtype\" ) / ( %s\"/BaseFont\" ) / ( %s\"/Encoding\" ) name")
  (or
   (pdf-cst-list-list-conc-matchp cstss "( %s\"/Subtype\" )")
   (pdf-cst-list-list-conc-matchp cstss "( %s\"/BaseFont\" )")
   (pdf-cst-list-list-conc-matchp cstss "( %s\"/Encoding\" ) name"))))

Theorem: pdf-cst-font-entry-concs

(defthm pdf-cst-font-entry-concs
  (implies
       (pdf-cst-list-list-alt-matchp cstss "%s\"/Font\" font")
       (or (pdf-cst-list-list-conc-matchp cstss "%s\"/Font\" font"))))

Theorem: pdf-cst-font-concs

(defthm pdf-cst-font-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "start-dict name reference end-dict")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "start-dict name reference end-dict"))))

Theorem: pdf-cst-dict-key-concs

(defthm pdf-cst-dict-key-concs
 (implies
      (pdf-cst-list-list-alt-matchp cstss "backslash *char")
      (or (pdf-cst-list-list-conc-matchp cstss "backslash *char"))))

Theorem: pdf-cst-dict-value-concs

(defthm pdf-cst-dict-value-concs
 (implies
  (pdf-cst-list-list-alt-matchp
   cstss
   "boolean / number / name / array / dictionary / null / rectangle / reference / string")
  (or (pdf-cst-list-list-conc-matchp cstss "boolean")
      (pdf-cst-list-list-conc-matchp cstss "number")
      (pdf-cst-list-list-conc-matchp cstss "name")
      (pdf-cst-list-list-conc-matchp cstss "array")
      (pdf-cst-list-list-conc-matchp cstss "dictionary")
      (pdf-cst-list-list-conc-matchp cstss "null")
      (pdf-cst-list-list-conc-matchp cstss "rectangle")
      (pdf-cst-list-list-conc-matchp cstss "reference")
      (pdf-cst-list-list-conc-matchp cstss "string"))))

Theorem: pdf-cst-start-dict-concs

(defthm pdf-cst-start-dict-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x3C.3C")
           (or (pdf-cst-list-list-conc-matchp cstss "%x3C.3C"))))

Theorem: pdf-cst-end-dict-concs

(defthm pdf-cst-end-dict-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x3E.3E")
           (or (pdf-cst-list-list-conc-matchp cstss "%x3E.3E"))))

Theorem: pdf-cst-ws-concs

(defthm pdf-cst-ws-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )"))))

Theorem: pdf-cst-digit1-9-concs

(defthm pdf-cst-digit1-9-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x31-39")
           (or (pdf-cst-list-list-conc-matchp cstss "%x31-39"))))

Theorem: pdf-cst-digit-concs

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

Theorem: pdf-cst-boolean-concs

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

Theorem: pdf-cst-array-concs

(defthm pdf-cst-array-concs
 (implies
   (pdf-cst-list-list-alt-matchp cstss
                                 "left-bracket *char right-bracket")
   (or (pdf-cst-list-list-conc-matchp
            cstss
            "left-bracket *char right-bracket"))))

Theorem: pdf-cst-reference-array-concs

(defthm pdf-cst-reference-array-concs
  (implies (pdf-cst-list-list-alt-matchp
                cstss
                "left-bracket *reference right-bracket")
           (or (pdf-cst-list-list-conc-matchp
                    cstss
                    "left-bracket *reference right-bracket"))))

Theorem: pdf-cst-reference-concs

(defthm pdf-cst-reference-concs
 (implies
   (pdf-cst-list-list-alt-matchp cstss "int %x20 zero %x52")
   (or (pdf-cst-list-list-conc-matchp cstss "int %x20 zero %x52"))))

Theorem: pdf-cst-rectangle-concs

(defthm pdf-cst-rectangle-concs
 (implies
  (pdf-cst-list-list-alt-matchp
       cstss
       "left-bracket number number number number right-bracket")
  (or
   (pdf-cst-list-list-conc-matchp
        cstss
        "left-bracket number number number number right-bracket"))))

Theorem: pdf-cst-left-bracket-concs

(defthm pdf-cst-left-bracket-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x5B")
           (or (pdf-cst-list-list-conc-matchp cstss "%x5B"))))

Theorem: pdf-cst-right-bracket-concs

(defthm pdf-cst-right-bracket-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x5D")
           (or (pdf-cst-list-list-conc-matchp cstss "%x5D"))))

Theorem: pdf-cst-number-concs

(defthm pdf-cst-number-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "[ plus / minus ] real / int")
  (or (pdf-cst-list-list-conc-matchp cstss "[ plus / minus ] real")
      (pdf-cst-list-list-conc-matchp cstss "int"))))

Theorem: pdf-cst-null-concs

(defthm pdf-cst-null-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%s\"null\"")
           (or (pdf-cst-list-list-conc-matchp cstss "%s\"null\""))))

Theorem: pdf-cst-name-concs

(defthm pdf-cst-name-concs
 (implies
      (pdf-cst-list-list-alt-matchp cstss "slash name-char")
      (or (pdf-cst-list-list-conc-matchp cstss "slash name-char"))))

Theorem: pdf-cst-name-char-concs

(defthm pdf-cst-name-char-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x20-7E")
           (or (pdf-cst-list-list-conc-matchp cstss "%x20-7E"))))

Theorem: pdf-cst-real-concs

(defthm pdf-cst-real-concs
  (implies
       (pdf-cst-list-list-alt-matchp cstss "int period int")
       (or (pdf-cst-list-list-conc-matchp cstss "int period int"))))

Theorem: pdf-cst-int-concs

(defthm pdf-cst-int-concs
 (implies
  (pdf-cst-list-list-alt-matchp cstss "zero / ( digit1-9 *digit )")
  (or (pdf-cst-list-list-conc-matchp cstss "zero")
      (pdf-cst-list-list-conc-matchp cstss "( digit1-9 *digit )"))))

Theorem: pdf-cst-plus-concs

(defthm pdf-cst-plus-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x2B")
           (or (pdf-cst-list-list-conc-matchp cstss "%x2B"))))

Theorem: pdf-cst-minus-concs

(defthm pdf-cst-minus-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x2D")
           (or (pdf-cst-list-list-conc-matchp cstss "%x2D"))))

Theorem: pdf-cst-slash-concs

(defthm pdf-cst-slash-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x2F")
           (or (pdf-cst-list-list-conc-matchp cstss "%x2F"))))

Theorem: pdf-cst-backslash-concs

(defthm pdf-cst-backslash-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x5C")
           (or (pdf-cst-list-list-conc-matchp cstss "%x5C"))))

Theorem: pdf-cst-zero-concs

(defthm pdf-cst-zero-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x30")
           (or (pdf-cst-list-list-conc-matchp cstss "%x30"))))

Theorem: pdf-cst-string-concs

(defthm pdf-cst-string-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "*char")
           (or (pdf-cst-list-list-conc-matchp cstss "*char"))))

Theorem: pdf-cst-period-concs

(defthm pdf-cst-period-concs
  (implies (pdf-cst-list-list-alt-matchp cstss "%x2E")
           (or (pdf-cst-list-list-conc-matchp cstss "%x2E"))))

Theorem: pdf-cst-char-concs

(defthm pdf-cst-char-concs
 (implies (pdf-cst-list-list-alt-matchp
               cstss "%x20-21 / %x23-5B / %x5D-10FFFF")
          (or (pdf-cst-list-list-conc-matchp cstss "%x20-21")
              (pdf-cst-list-list-conc-matchp cstss "%x23-5B")
              (pdf-cst-list-list-conc-matchp cstss "%x5D-10FFFF"))))

Theorem: pdf-cst-pdf-marker-conc-matching

(defthm pdf-cst-pdf-marker-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x25.50.44.46.45")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x25.50.44.46.45"))))

Theorem: pdf-cst-objects-conc-matching

(defthm pdf-cst-objects-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "*object")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "*object"))))

Theorem: pdf-cst-obj-marker-conc-matching

(defthm pdf-cst-obj-marker-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x6F.62.6A")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x6F.62.6A"))))

Theorem: pdf-cst-endobj-marker-conc-matching

(defthm pdf-cst-endobj-marker-conc-matching
  (implies
       (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.6F.62.6A")
       (and (equal (len cstss) 1)
            (pdf-cst-list-rep-matchp (nth 0 cstss)
                                     "%x65.6E.64.6F.62.6A"))))

Theorem: pdf-cst-stream-marker-conc-matching

(defthm pdf-cst-stream-marker-conc-matching
  (implies
       (pdf-cst-list-list-conc-matchp cstss "%x73.74.72.65.61.6D")
       (and (equal (len cstss) 1)
            (pdf-cst-list-rep-matchp (nth 0 cstss)
                                     "%x73.74.72.65.61.6D"))))

Theorem: pdf-cst-endstream-marker-conc-matching

(defthm pdf-cst-endstream-marker-conc-matching
 (implies
    (pdf-cst-list-list-conc-matchp
         cstss "%x65.6E.64.73.74.72.65.61.6D")
    (and (equal (len cstss) 1)
         (pdf-cst-list-rep-matchp (nth 0 cstss)
                                  "%x65.6E.64.73.74.72.65.61.6D"))))

Theorem: pdf-cst-use-marker-conc1-matching

(defthm pdf-cst-use-marker-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x6E")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x6E"))))

Theorem: pdf-cst-use-marker-conc2-matching

(defthm pdf-cst-use-marker-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x66")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x66"))))

Theorem: pdf-cst-xref-marker-conc-matching

(defthm pdf-cst-xref-marker-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x78.72.65.66")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x78.72.65.66"))))

Theorem: pdf-cst-xref-int-conc-matching

(defthm pdf-cst-xref-int-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "*digit")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "*digit"))))

Theorem: pdf-cst-startxref-marker-conc-matching

(defthm pdf-cst-startxref-marker-conc-matching
 (implies
    (pdf-cst-list-list-conc-matchp
         cstss "%x73.74.61.72.74.78.72.65.66")
    (and (equal (len cstss) 1)
         (pdf-cst-list-rep-matchp (nth 0 cstss)
                                  "%x73.74.61.72.74.78.72.65.66"))))

Theorem: pdf-cst-eof-marker-conc-matching

(defthm pdf-cst-eof-marker-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x25.25.45.4F.46")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x25.25.45.4F.46"))))

Theorem: pdf-cst-trailer-key-and-value-conc1-matching

(defthm pdf-cst-trailer-key-and-value-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Size\" int )")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "( %s\"/Size\" int )"))))

Theorem: pdf-cst-trailer-key-and-value-conc2-matching

(defthm pdf-cst-trailer-key-and-value-conc2-matching
 (implies
     (pdf-cst-list-list-conc-matchp cstss "( %s\"/Root\" reference )")
     (and (equal (len cstss) 1)
          (pdf-cst-list-rep-matchp (nth 0 cstss)
                                   "( %s\"/Root\" reference )"))))

Theorem: pdf-cst-trailer-key-and-value-conc3-matching

(defthm pdf-cst-trailer-key-and-value-conc3-matching
 (implies
     (pdf-cst-list-list-conc-matchp cstss "( %s\"/Info\" reference )")
     (and (equal (len cstss) 1)
          (pdf-cst-list-rep-matchp (nth 0 cstss)
                                   "( %s\"/Info\" reference )"))))

Theorem: pdf-cst-trailer-key-and-value-conc4-matching

(defthm pdf-cst-trailer-key-and-value-conc4-matching
 (implies
  (pdf-cst-list-list-conc-matchp
       cstss
       "( %s\"/ID\" left-bracket string string right-bracket )")
  (and
     (equal (len cstss) 1)
     (pdf-cst-list-rep-matchp
          (nth 0 cstss)
          "( %s\"/ID\" left-bracket string string right-bracket )"))))

Theorem: pdf-cst-trailer-marker-conc-matching

(defthm pdf-cst-trailer-marker-conc-matching
 (implies
      (pdf-cst-list-list-conc-matchp cstss "%x74.72.61.69.6C.65.72")
      (and (equal (len cstss) 1)
           (pdf-cst-list-rep-matchp (nth 0 cstss)
                                    "%x74.72.61.69.6C.65.72"))))

Theorem: pdf-cst-dict-entry-conc1-matching

(defthm pdf-cst-dict-entry-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "type-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "type-entry"))))

Theorem: pdf-cst-dict-entry-conc2-matching

(defthm pdf-cst-dict-entry-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "reference-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "reference-entry"))))

Theorem: pdf-cst-dict-entry-conc3-matching

(defthm pdf-cst-dict-entry-conc3-matching
  (implies
       (pdf-cst-list-list-conc-matchp cstss "reference-array-entry")
       (and (equal (len cstss) 1)
            (pdf-cst-list-rep-matchp (nth 0 cstss)
                                     "reference-array-entry"))))

Theorem: pdf-cst-dict-entry-conc4-matching

(defthm pdf-cst-dict-entry-conc4-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "rectangle-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "rectangle-entry"))))

Theorem: pdf-cst-dict-entry-conc5-matching

(defthm pdf-cst-dict-entry-conc5-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "number-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "number-entry"))))

Theorem: pdf-cst-dict-entry-conc6-matching

(defthm pdf-cst-dict-entry-conc6-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "name-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "name-entry"))))

Theorem: pdf-cst-dict-entry-conc7-matching

(defthm pdf-cst-dict-entry-conc7-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "font-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "font-entry"))))

Theorem: pdf-cst-dict-entry-conc8-matching

(defthm pdf-cst-dict-entry-conc8-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "default-entry")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "default-entry"))))

Theorem: pdf-cst-reference-entry-conc1-matching

(defthm pdf-cst-reference-entry-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/Parent\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"/Parent\""))))

Theorem: pdf-cst-reference-entry-conc2-matching

(defthm pdf-cst-reference-entry-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/Pages\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"/Pages\""))))

Theorem: pdf-cst-reference-entry-conc3-matching

(defthm pdf-cst-reference-entry-conc3-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/Contents\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"/Contents\""))))

Theorem: pdf-cst-rectangle-entry-conc1-matching

(defthm pdf-cst-rectangle-entry-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"/MediaBox\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"/MediaBox\""))))

Theorem: pdf-cst-number-entry-conc1-matching

(defthm pdf-cst-number-entry-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Count\" )")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "( %s\"/Count\" )"))))

Theorem: pdf-cst-name-entry-conc1-matching

(defthm pdf-cst-name-entry-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/Subtype\" )")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "( %s\"/Subtype\" )"))))

Theorem: pdf-cst-name-entry-conc2-matching

(defthm pdf-cst-name-entry-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "( %s\"/BaseFont\" )")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "( %s\"/BaseFont\" )"))))

Theorem: pdf-cst-dict-value-conc1-matching

(defthm pdf-cst-dict-value-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "boolean")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "boolean"))))

Theorem: pdf-cst-dict-value-conc2-matching

(defthm pdf-cst-dict-value-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "number")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "number"))))

Theorem: pdf-cst-dict-value-conc3-matching

(defthm pdf-cst-dict-value-conc3-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "name")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "name"))))

Theorem: pdf-cst-dict-value-conc4-matching

(defthm pdf-cst-dict-value-conc4-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "array")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "array"))))

Theorem: pdf-cst-dict-value-conc5-matching

(defthm pdf-cst-dict-value-conc5-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "dictionary")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "dictionary"))))

Theorem: pdf-cst-dict-value-conc6-matching

(defthm pdf-cst-dict-value-conc6-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "null")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "null"))))

Theorem: pdf-cst-dict-value-conc7-matching

(defthm pdf-cst-dict-value-conc7-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "rectangle")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "rectangle"))))

Theorem: pdf-cst-dict-value-conc8-matching

(defthm pdf-cst-dict-value-conc8-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "reference")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "reference"))))

Theorem: pdf-cst-dict-value-conc9-matching

(defthm pdf-cst-dict-value-conc9-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "string")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "string"))))

Theorem: pdf-cst-start-dict-conc-matching

(defthm pdf-cst-start-dict-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x3C.3C")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x3C.3C"))))

Theorem: pdf-cst-end-dict-conc-matching

(defthm pdf-cst-end-dict-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x3E.3E")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x3E.3E"))))

Theorem: pdf-cst-ws-conc-matching

(defthm pdf-cst-ws-conc-matching
  (implies (pdf-cst-list-list-conc-matchp
                cstss
                "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp
                     (nth 0 cstss)
                     "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )"))))

Theorem: pdf-cst-digit1-9-conc-matching

(defthm pdf-cst-digit1-9-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x31-39")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x31-39"))))

Theorem: pdf-cst-digit-conc-matching

(defthm pdf-cst-digit-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x30-39")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x30-39"))))

Theorem: pdf-cst-boolean-conc1-matching

(defthm pdf-cst-boolean-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"true\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"true\""))))

Theorem: pdf-cst-boolean-conc2-matching

(defthm pdf-cst-boolean-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"false\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"false\""))))

Theorem: pdf-cst-left-bracket-conc-matching

(defthm pdf-cst-left-bracket-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x5B")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x5B"))))

Theorem: pdf-cst-right-bracket-conc-matching

(defthm pdf-cst-right-bracket-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x5D")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x5D"))))

Theorem: pdf-cst-number-conc2-matching

(defthm pdf-cst-number-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "int")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "int"))))

Theorem: pdf-cst-null-conc-matching

(defthm pdf-cst-null-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%s\"null\"")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%s\"null\""))))

Theorem: pdf-cst-name-char-conc-matching

(defthm pdf-cst-name-char-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x20-7E")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x20-7E"))))

Theorem: pdf-cst-int-conc1-matching

(defthm pdf-cst-int-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "zero")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "zero"))))

Theorem: pdf-cst-int-conc2-matching

(defthm pdf-cst-int-conc2-matching
  (implies
       (pdf-cst-list-list-conc-matchp cstss "( digit1-9 *digit )")
       (and (equal (len cstss) 1)
            (pdf-cst-list-rep-matchp (nth 0 cstss)
                                     "( digit1-9 *digit )"))))

Theorem: pdf-cst-plus-conc-matching

(defthm pdf-cst-plus-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x2B")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x2B"))))

Theorem: pdf-cst-minus-conc-matching

(defthm pdf-cst-minus-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x2D")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x2D"))))

Theorem: pdf-cst-slash-conc-matching

(defthm pdf-cst-slash-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x2F")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x2F"))))

Theorem: pdf-cst-backslash-conc-matching

(defthm pdf-cst-backslash-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x5C")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x5C"))))

Theorem: pdf-cst-zero-conc-matching

(defthm pdf-cst-zero-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x30")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x30"))))

Theorem: pdf-cst-string-conc-matching

(defthm pdf-cst-string-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "*char")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "*char"))))

Theorem: pdf-cst-period-conc-matching

(defthm pdf-cst-period-conc-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x2E")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x2E"))))

Theorem: pdf-cst-char-conc1-matching

(defthm pdf-cst-char-conc1-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x20-21")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x20-21"))))

Theorem: pdf-cst-char-conc2-matching

(defthm pdf-cst-char-conc2-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x23-5B")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x23-5B"))))

Theorem: pdf-cst-char-conc3-matching

(defthm pdf-cst-char-conc3-matching
  (implies (pdf-cst-list-list-conc-matchp cstss "%x5D-10FFFF")
           (and (equal (len cstss) 1)
                (pdf-cst-list-rep-matchp (nth 0 cstss)
                                         "%x5D-10FFFF"))))

Theorem: pdf-cst-pdf-marker-conc-rep-matching

(defthm pdf-cst-pdf-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x25.50.44.46.45")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x25.50.44.46.45"))))

Theorem: pdf-cst-obj-marker-conc-rep-matching

(defthm pdf-cst-obj-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x6F.62.6A")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x6F.62.6A"))))

Theorem: pdf-cst-endobj-marker-conc-rep-matching

(defthm pdf-cst-endobj-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x65.6E.64.6F.62.6A")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x65.6E.64.6F.62.6A"))))

Theorem: pdf-cst-stream-marker-conc-rep-matching

(defthm pdf-cst-stream-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x73.74.72.65.61.6D")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x73.74.72.65.61.6D"))))

Theorem: pdf-cst-endstream-marker-conc-rep-matching

(defthm pdf-cst-endstream-marker-conc-rep-matching
  (implies
       (pdf-cst-list-rep-matchp csts "%x65.6E.64.73.74.72.65.61.6D")
       (and (equal (len csts) 1)
            (pdf-cst-matchp (nth 0 csts)
                            "%x65.6E.64.73.74.72.65.61.6D"))))

Theorem: pdf-cst-use-marker-conc1-rep-matching

(defthm pdf-cst-use-marker-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x6E")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x6E"))))

Theorem: pdf-cst-use-marker-conc2-rep-matching

(defthm pdf-cst-use-marker-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x66")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x66"))))

Theorem: pdf-cst-xref-marker-conc-rep-matching

(defthm pdf-cst-xref-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x78.72.65.66")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x78.72.65.66"))))

Theorem: pdf-cst-startxref-marker-conc-rep-matching

(defthm pdf-cst-startxref-marker-conc-rep-matching
  (implies
       (pdf-cst-list-rep-matchp csts "%x73.74.61.72.74.78.72.65.66")
       (and (equal (len csts) 1)
            (pdf-cst-matchp (nth 0 csts)
                            "%x73.74.61.72.74.78.72.65.66"))))

Theorem: pdf-cst-eof-marker-conc-rep-matching

(defthm pdf-cst-eof-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x25.25.45.4F.46")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x25.25.45.4F.46"))))

Theorem: pdf-cst-trailer-key-and-value-conc1-rep-matching

(defthm pdf-cst-trailer-key-and-value-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( %s\"/Size\" int )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( %s\"/Size\" int )"))))

Theorem: pdf-cst-trailer-key-and-value-conc2-rep-matching

(defthm pdf-cst-trailer-key-and-value-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( %s\"/Root\" reference )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( %s\"/Root\" reference )"))))

Theorem: pdf-cst-trailer-key-and-value-conc3-rep-matching

(defthm pdf-cst-trailer-key-and-value-conc3-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( %s\"/Info\" reference )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( %s\"/Info\" reference )"))))

Theorem: pdf-cst-trailer-key-and-value-conc4-rep-matching

(defthm pdf-cst-trailer-key-and-value-conc4-rep-matching
 (implies
  (pdf-cst-list-rep-matchp
       csts
       "( %s\"/ID\" left-bracket string string right-bracket )")
  (and
     (equal (len csts) 1)
     (pdf-cst-matchp
          (nth 0 csts)
          "( %s\"/ID\" left-bracket string string right-bracket )"))))

Theorem: pdf-cst-trailer-marker-conc-rep-matching

(defthm pdf-cst-trailer-marker-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x74.72.61.69.6C.65.72")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x74.72.61.69.6C.65.72"))))

Theorem: pdf-cst-dict-entry-conc1-rep-matching

(defthm pdf-cst-dict-entry-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "type-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "type-entry"))))

Theorem: pdf-cst-dict-entry-conc2-rep-matching

(defthm pdf-cst-dict-entry-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "reference-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "reference-entry"))))

Theorem: pdf-cst-dict-entry-conc3-rep-matching

(defthm pdf-cst-dict-entry-conc3-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "reference-array-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "reference-array-entry"))))

Theorem: pdf-cst-dict-entry-conc4-rep-matching

(defthm pdf-cst-dict-entry-conc4-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "rectangle-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "rectangle-entry"))))

Theorem: pdf-cst-dict-entry-conc5-rep-matching

(defthm pdf-cst-dict-entry-conc5-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "number-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "number-entry"))))

Theorem: pdf-cst-dict-entry-conc6-rep-matching

(defthm pdf-cst-dict-entry-conc6-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "name-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "name-entry"))))

Theorem: pdf-cst-dict-entry-conc7-rep-matching

(defthm pdf-cst-dict-entry-conc7-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "font-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "font-entry"))))

Theorem: pdf-cst-dict-entry-conc8-rep-matching

(defthm pdf-cst-dict-entry-conc8-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "default-entry")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "default-entry"))))

Theorem: pdf-cst-reference-entry-conc1-rep-matching

(defthm pdf-cst-reference-entry-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"/Parent\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"/Parent\""))))

Theorem: pdf-cst-reference-entry-conc2-rep-matching

(defthm pdf-cst-reference-entry-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"/Pages\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"/Pages\""))))

Theorem: pdf-cst-reference-entry-conc3-rep-matching

(defthm pdf-cst-reference-entry-conc3-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"/Contents\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"/Contents\""))))

Theorem: pdf-cst-rectangle-entry-conc1-rep-matching

(defthm pdf-cst-rectangle-entry-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"/MediaBox\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"/MediaBox\""))))

Theorem: pdf-cst-number-entry-conc1-rep-matching

(defthm pdf-cst-number-entry-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( %s\"/Count\" )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( %s\"/Count\" )"))))

Theorem: pdf-cst-name-entry-conc1-rep-matching

(defthm pdf-cst-name-entry-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( %s\"/Subtype\" )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( %s\"/Subtype\" )"))))

Theorem: pdf-cst-name-entry-conc2-rep-matching

(defthm pdf-cst-name-entry-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( %s\"/BaseFont\" )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( %s\"/BaseFont\" )"))))

Theorem: pdf-cst-dict-value-conc1-rep-matching

(defthm pdf-cst-dict-value-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "boolean")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "boolean"))))

Theorem: pdf-cst-dict-value-conc2-rep-matching

(defthm pdf-cst-dict-value-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "number")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "number"))))

Theorem: pdf-cst-dict-value-conc3-rep-matching

(defthm pdf-cst-dict-value-conc3-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "name")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "name"))))

Theorem: pdf-cst-dict-value-conc4-rep-matching

(defthm pdf-cst-dict-value-conc4-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "array")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "array"))))

Theorem: pdf-cst-dict-value-conc5-rep-matching

(defthm pdf-cst-dict-value-conc5-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "dictionary")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "dictionary"))))

Theorem: pdf-cst-dict-value-conc6-rep-matching

(defthm pdf-cst-dict-value-conc6-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "null")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "null"))))

Theorem: pdf-cst-dict-value-conc7-rep-matching

(defthm pdf-cst-dict-value-conc7-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "rectangle")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "rectangle"))))

Theorem: pdf-cst-dict-value-conc8-rep-matching

(defthm pdf-cst-dict-value-conc8-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "reference")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "reference"))))

Theorem: pdf-cst-dict-value-conc9-rep-matching

(defthm pdf-cst-dict-value-conc9-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "string")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "string"))))

Theorem: pdf-cst-start-dict-conc-rep-matching

(defthm pdf-cst-start-dict-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x3C.3C")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x3C.3C"))))

Theorem: pdf-cst-end-dict-conc-rep-matching

(defthm pdf-cst-end-dict-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x3E.3E")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x3E.3E"))))

Theorem: pdf-cst-digit1-9-conc-rep-matching

(defthm pdf-cst-digit1-9-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x31-39")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x31-39"))))

Theorem: pdf-cst-digit-conc-rep-matching

(defthm pdf-cst-digit-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x30-39")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x30-39"))))

Theorem: pdf-cst-boolean-conc1-rep-matching

(defthm pdf-cst-boolean-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"true\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"true\""))))

Theorem: pdf-cst-boolean-conc2-rep-matching

(defthm pdf-cst-boolean-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"false\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"false\""))))

Theorem: pdf-cst-left-bracket-conc-rep-matching

(defthm pdf-cst-left-bracket-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x5B")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x5B"))))

Theorem: pdf-cst-right-bracket-conc-rep-matching

(defthm pdf-cst-right-bracket-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x5D")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x5D"))))

Theorem: pdf-cst-number-conc2-rep-matching

(defthm pdf-cst-number-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "int")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "int"))))

Theorem: pdf-cst-null-conc-rep-matching

(defthm pdf-cst-null-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%s\"null\"")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%s\"null\""))))

Theorem: pdf-cst-name-char-conc-rep-matching

(defthm pdf-cst-name-char-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x20-7E")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x20-7E"))))

Theorem: pdf-cst-int-conc1-rep-matching

(defthm pdf-cst-int-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "zero")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "zero"))))

Theorem: pdf-cst-int-conc2-rep-matching

(defthm pdf-cst-int-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "( digit1-9 *digit )")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "( digit1-9 *digit )"))))

Theorem: pdf-cst-plus-conc-rep-matching

(defthm pdf-cst-plus-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x2B")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x2B"))))

Theorem: pdf-cst-minus-conc-rep-matching

(defthm pdf-cst-minus-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x2D")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x2D"))))

Theorem: pdf-cst-slash-conc-rep-matching

(defthm pdf-cst-slash-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x2F")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x2F"))))

Theorem: pdf-cst-backslash-conc-rep-matching

(defthm pdf-cst-backslash-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x5C")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x5C"))))

Theorem: pdf-cst-zero-conc-rep-matching

(defthm pdf-cst-zero-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x30")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x30"))))

Theorem: pdf-cst-period-conc-rep-matching

(defthm pdf-cst-period-conc-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x2E")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts) "%x2E"))))

Theorem: pdf-cst-char-conc1-rep-matching

(defthm pdf-cst-char-conc1-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x20-21")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x20-21"))))

Theorem: pdf-cst-char-conc2-rep-matching

(defthm pdf-cst-char-conc2-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x23-5B")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x23-5B"))))

Theorem: pdf-cst-char-conc3-rep-matching

(defthm pdf-cst-char-conc3-rep-matching
  (implies (pdf-cst-list-rep-matchp csts "%x5D-10FFFF")
           (and (equal (len csts) 1)
                (pdf-cst-matchp (nth 0 csts)
                                "%x5D-10FFFF"))))

Theorem: pdf-cst-dict-entry-conc-equivs

(defthm pdf-cst-dict-entry-conc-equivs
 (implies
  (pdf-cst-matchp cst "dict-entry")
  (and
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "type-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "type-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "reference-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "reference-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "reference-array-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "reference-array-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "rectangle-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "rectangle-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "number-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "number-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "name-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "name-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "font-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "font-entry")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "default-entry")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "default-entry"))))))

Theorem: pdf-cst-dict-value-conc-equivs

(defthm pdf-cst-dict-value-conc-equivs
 (implies
  (pdf-cst-matchp cst "dict-value")
  (and
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "boolean")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "boolean")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "number")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "number")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "name")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "name")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "array")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "array")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dictionary")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "dictionary")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "null")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "null")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "rectangle")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "rectangle")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "reference")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "reference")))
    (iff (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "string")
         (equal (tree-nonleaf->rulename?
                     (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                (rulename "string"))))))

Function: pdf-cst-dict-entry-conc?

(defun pdf-cst-dict-entry-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "dict-entry")))
  (let ((__function__ 'pdf-cst-dict-entry-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "type-entry"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "reference-entry"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "reference-array-entry"))
           3)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "rectangle-entry"))
           4)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "number-entry"))
           5)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "name-entry"))
           6)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "font-entry"))
           7)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "default-entry"))
           8)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-pdf-cst-dict-entry-conc?

(defthm posp-of-pdf-cst-dict-entry-conc?
  (b* ((number (pdf-cst-dict-entry-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc?-possibilities

(defthm pdf-cst-dict-entry-conc?-possibilities
  (b* ((number (pdf-cst-dict-entry-conc? cst)))
    (or (equal number 1)
        (equal number 2)
        (equal number 3)
        (equal number 4)
        (equal number 5)
        (equal number 6)
        (equal number 7)
        (equal number 8)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((pdf-cst-dict-entry-conc? cst)))))

Theorem: pdf-cst-dict-entry-conc?-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc?-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc? (tree-fix cst))
         (pdf-cst-dict-entry-conc? cst)))

Theorem: pdf-cst-dict-entry-conc?-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc? cst)
                  (pdf-cst-dict-entry-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: pdf-cst-dict-entry-conc?-1-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-1-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 1)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "type-entry"))))

Theorem: pdf-cst-dict-entry-conc?-2-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-2-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 2)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "reference-entry"))))

Theorem: pdf-cst-dict-entry-conc?-3-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-3-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 3)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "reference-array-entry"))))

Theorem: pdf-cst-dict-entry-conc?-4-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-4-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 4)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "rectangle-entry"))))

Theorem: pdf-cst-dict-entry-conc?-5-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-5-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 5)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "number-entry"))))

Theorem: pdf-cst-dict-entry-conc?-6-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-6-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 6)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "name-entry"))))

Theorem: pdf-cst-dict-entry-conc?-7-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-7-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 7)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "font-entry"))))

Theorem: pdf-cst-dict-entry-conc?-8-iff-match-conc

(defthm pdf-cst-dict-entry-conc?-8-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-entry")
    (iff (equal (pdf-cst-dict-entry-conc? cst) 8)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "default-entry"))))

Function: pdf-cst-dict-value-conc?

(defun pdf-cst-dict-value-conc? (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "dict-value")))
  (let ((__function__ 'pdf-cst-dict-value-conc?))
    (declare (ignorable __function__))
    (cond ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "boolean"))
           1)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "number"))
           2)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "name"))
           3)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "array"))
           4)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "dictionary"))
           5)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "null"))
           6)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "rectangle"))
           7)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "reference"))
           8)
          ((equal (tree-nonleaf->rulename?
                       (nth 0 (nth 0 (tree-nonleaf->branches cst))))
                  (rulename "string"))
           9)
          (t (prog2$ (acl2::impossible) 1)))))

Theorem: posp-of-pdf-cst-dict-value-conc?

(defthm posp-of-pdf-cst-dict-value-conc?
  (b* ((number (pdf-cst-dict-value-conc? cst)))
    (posp number))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc?-possibilities

(defthm pdf-cst-dict-value-conc?-possibilities
  (b* ((number (pdf-cst-dict-value-conc? 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)))
  :rule-classes
  ((:forward-chaining
        :trigger-terms ((pdf-cst-dict-value-conc? cst)))))

Theorem: pdf-cst-dict-value-conc?-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc?-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc? (tree-fix cst))
         (pdf-cst-dict-value-conc? cst)))

Theorem: pdf-cst-dict-value-conc?-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc?-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc? cst)
                  (pdf-cst-dict-value-conc? cst-equiv)))
  :rule-classes :congruence)

Theorem: pdf-cst-dict-value-conc?-1-iff-match-conc

(defthm pdf-cst-dict-value-conc?-1-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 1)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "boolean"))))

Theorem: pdf-cst-dict-value-conc?-2-iff-match-conc

(defthm pdf-cst-dict-value-conc?-2-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 2)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "number"))))

Theorem: pdf-cst-dict-value-conc?-3-iff-match-conc

(defthm pdf-cst-dict-value-conc?-3-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 3)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "name"))))

Theorem: pdf-cst-dict-value-conc?-4-iff-match-conc

(defthm pdf-cst-dict-value-conc?-4-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 4)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "array"))))

Theorem: pdf-cst-dict-value-conc?-5-iff-match-conc

(defthm pdf-cst-dict-value-conc?-5-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 5)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "dictionary"))))

Theorem: pdf-cst-dict-value-conc?-6-iff-match-conc

(defthm pdf-cst-dict-value-conc?-6-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 6)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "null"))))

Theorem: pdf-cst-dict-value-conc?-7-iff-match-conc

(defthm pdf-cst-dict-value-conc?-7-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 7)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "rectangle"))))

Theorem: pdf-cst-dict-value-conc?-8-iff-match-conc

(defthm pdf-cst-dict-value-conc?-8-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 8)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "reference"))))

Theorem: pdf-cst-dict-value-conc?-9-iff-match-conc

(defthm pdf-cst-dict-value-conc?-9-iff-match-conc
 (implies
    (pdf-cst-matchp cst "dict-value")
    (iff (equal (pdf-cst-dict-value-conc? cst) 9)
         (pdf-cst-list-list-conc-matchp (tree-nonleaf->branches cst)
                                        "string"))))

Function: pdf-cst-pdf-conc

(defun pdf-cst-pdf-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "pdf")))
  (let ((__function__ 'pdf-cst-pdf-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-pdf-conc

(defthm tree-list-listp-of-pdf-cst-pdf-conc
  (b* ((cstss (pdf-cst-pdf-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-conc-match

(defthm pdf-cst-pdf-conc-match
  (implies (pdf-cst-matchp cst "pdf")
           (b* ((cstss (pdf-cst-pdf-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss "header objects xref trailer")))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-conc-of-tree-fix-cst

(defthm pdf-cst-pdf-conc-of-tree-fix-cst
  (equal (pdf-cst-pdf-conc (tree-fix cst))
         (pdf-cst-pdf-conc cst)))

Theorem: pdf-cst-pdf-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-pdf-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-pdf-conc cst)
                  (pdf-cst-pdf-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-header-conc

(defun pdf-cst-header-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "header")))
  (let ((__function__ 'pdf-cst-header-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-header-conc

(defthm tree-list-listp-of-pdf-cst-header-conc
  (b* ((cstss (pdf-cst-header-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-header-conc-match

(defthm pdf-cst-header-conc-match
  (implies (pdf-cst-matchp cst "header")
           (b* ((cstss (pdf-cst-header-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss "pdf-marker int period int ws")))
  :rule-classes :rewrite)

Theorem: pdf-cst-header-conc-of-tree-fix-cst

(defthm pdf-cst-header-conc-of-tree-fix-cst
  (equal (pdf-cst-header-conc (tree-fix cst))
         (pdf-cst-header-conc cst)))

Theorem: pdf-cst-header-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-header-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-header-conc cst)
                  (pdf-cst-header-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-pdf-marker-conc

(defun pdf-cst-pdf-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "pdf-marker")))
  (let ((__function__ 'pdf-cst-pdf-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-pdf-marker-conc

(defthm tree-list-listp-of-pdf-cst-pdf-marker-conc
  (b* ((cstss (pdf-cst-pdf-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-marker-conc-match

(defthm pdf-cst-pdf-marker-conc-match
  (implies
       (pdf-cst-matchp cst "pdf-marker")
       (b* ((cstss (pdf-cst-pdf-marker-conc cst)))
         (pdf-cst-list-list-conc-matchp cstss "%x25.50.44.46.45")))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-marker-conc-of-tree-fix-cst

(defthm pdf-cst-pdf-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-pdf-marker-conc (tree-fix cst))
         (pdf-cst-pdf-marker-conc cst)))

Theorem: pdf-cst-pdf-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-pdf-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-pdf-marker-conc cst)
                  (pdf-cst-pdf-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-objects-conc

(defun pdf-cst-objects-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "objects")))
  (let ((__function__ 'pdf-cst-objects-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-objects-conc

(defthm tree-list-listp-of-pdf-cst-objects-conc
  (b* ((cstss (pdf-cst-objects-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-objects-conc-match

(defthm pdf-cst-objects-conc-match
  (implies (pdf-cst-matchp cst "objects")
           (b* ((cstss (pdf-cst-objects-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "*object")))
  :rule-classes :rewrite)

Theorem: pdf-cst-objects-conc-of-tree-fix-cst

(defthm pdf-cst-objects-conc-of-tree-fix-cst
  (equal (pdf-cst-objects-conc (tree-fix cst))
         (pdf-cst-objects-conc cst)))

Theorem: pdf-cst-objects-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-objects-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-objects-conc cst)
                  (pdf-cst-objects-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-object-conc

(defun pdf-cst-object-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "object")))
  (let ((__function__ 'pdf-cst-object-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-object-conc

(defthm tree-list-listp-of-pdf-cst-object-conc
  (b* ((cstss (pdf-cst-object-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-object-conc-match

(defthm pdf-cst-object-conc-match
 (implies
  (pdf-cst-matchp cst "object")
  (b* ((cstss (pdf-cst-object-conc cst)))
   (pdf-cst-list-list-conc-matchp
    cstss
    "int ws zero obj-marker ws dictionary ws [ stream ] endobj-marker")))
 :rule-classes :rewrite)

Theorem: pdf-cst-object-conc-of-tree-fix-cst

(defthm pdf-cst-object-conc-of-tree-fix-cst
  (equal (pdf-cst-object-conc (tree-fix cst))
         (pdf-cst-object-conc cst)))

Theorem: pdf-cst-object-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-object-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-object-conc cst)
                  (pdf-cst-object-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-obj-marker-conc

(defun pdf-cst-obj-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "obj-marker")))
  (let ((__function__ 'pdf-cst-obj-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-obj-marker-conc

(defthm tree-list-listp-of-pdf-cst-obj-marker-conc
  (b* ((cstss (pdf-cst-obj-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-obj-marker-conc-match

(defthm pdf-cst-obj-marker-conc-match
  (implies (pdf-cst-matchp cst "obj-marker")
           (b* ((cstss (pdf-cst-obj-marker-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x6F.62.6A")))
  :rule-classes :rewrite)

Theorem: pdf-cst-obj-marker-conc-of-tree-fix-cst

(defthm pdf-cst-obj-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-obj-marker-conc (tree-fix cst))
         (pdf-cst-obj-marker-conc cst)))

Theorem: pdf-cst-obj-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-obj-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-obj-marker-conc cst)
                  (pdf-cst-obj-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-endobj-marker-conc

(defun pdf-cst-endobj-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "endobj-marker")))
  (let ((__function__ 'pdf-cst-endobj-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-endobj-marker-conc

(defthm tree-list-listp-of-pdf-cst-endobj-marker-conc
  (b* ((cstss (pdf-cst-endobj-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-endobj-marker-conc-match

(defthm pdf-cst-endobj-marker-conc-match
 (implies
     (pdf-cst-matchp cst "endobj-marker")
     (b* ((cstss (pdf-cst-endobj-marker-conc cst)))
       (pdf-cst-list-list-conc-matchp cstss "%x65.6E.64.6F.62.6A")))
 :rule-classes :rewrite)

Theorem: pdf-cst-endobj-marker-conc-of-tree-fix-cst

(defthm pdf-cst-endobj-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-endobj-marker-conc (tree-fix cst))
         (pdf-cst-endobj-marker-conc cst)))

Theorem: pdf-cst-endobj-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-endobj-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-endobj-marker-conc cst)
                  (pdf-cst-endobj-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-stream-conc

(defun pdf-cst-stream-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "stream")))
  (let ((__function__ 'pdf-cst-stream-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-stream-conc

(defthm tree-list-listp-of-pdf-cst-stream-conc
  (b* ((cstss (pdf-cst-stream-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-conc-match

(defthm pdf-cst-stream-conc-match
  (implies (pdf-cst-matchp cst "stream")
           (b* ((cstss (pdf-cst-stream-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "stream-marker *char endstream-marker")))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-conc-of-tree-fix-cst

(defthm pdf-cst-stream-conc-of-tree-fix-cst
  (equal (pdf-cst-stream-conc (tree-fix cst))
         (pdf-cst-stream-conc cst)))

Theorem: pdf-cst-stream-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-stream-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-stream-conc cst)
                  (pdf-cst-stream-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-stream-marker-conc

(defun pdf-cst-stream-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "stream-marker")))
  (let ((__function__ 'pdf-cst-stream-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-stream-marker-conc

(defthm tree-list-listp-of-pdf-cst-stream-marker-conc
  (b* ((cstss (pdf-cst-stream-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-marker-conc-match

(defthm pdf-cst-stream-marker-conc-match
 (implies
     (pdf-cst-matchp cst "stream-marker")
     (b* ((cstss (pdf-cst-stream-marker-conc cst)))
       (pdf-cst-list-list-conc-matchp cstss "%x73.74.72.65.61.6D")))
 :rule-classes :rewrite)

Theorem: pdf-cst-stream-marker-conc-of-tree-fix-cst

(defthm pdf-cst-stream-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-stream-marker-conc (tree-fix cst))
         (pdf-cst-stream-marker-conc cst)))

Theorem: pdf-cst-stream-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-stream-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-stream-marker-conc cst)
                  (pdf-cst-stream-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-endstream-marker-conc

(defun pdf-cst-endstream-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "endstream-marker")))
  (let ((__function__ 'pdf-cst-endstream-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-endstream-marker-conc

(defthm tree-list-listp-of-pdf-cst-endstream-marker-conc
  (b* ((cstss (pdf-cst-endstream-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-endstream-marker-conc-match

(defthm pdf-cst-endstream-marker-conc-match
  (implies (pdf-cst-matchp cst "endstream-marker")
           (b* ((cstss (pdf-cst-endstream-marker-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss "%x65.6E.64.73.74.72.65.61.6D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-endstream-marker-conc-of-tree-fix-cst

(defthm pdf-cst-endstream-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-endstream-marker-conc (tree-fix cst))
         (pdf-cst-endstream-marker-conc cst)))

Theorem: pdf-cst-endstream-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-endstream-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-endstream-marker-conc cst)
                  (pdf-cst-endstream-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-xref-conc

(defun pdf-cst-xref-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "xref")))
  (let ((__function__ 'pdf-cst-xref-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-xref-conc

(defthm tree-list-listp-of-pdf-cst-xref-conc
  (b* ((cstss (pdf-cst-xref-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-conc-match

(defthm pdf-cst-xref-conc-match
  (implies (pdf-cst-matchp cst "xref")
           (b* ((cstss (pdf-cst-xref-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "xref-marker ws zero ws int ws *xref-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-conc-of-tree-fix-cst

(defthm pdf-cst-xref-conc-of-tree-fix-cst
  (equal (pdf-cst-xref-conc (tree-fix cst))
         (pdf-cst-xref-conc cst)))

Theorem: pdf-cst-xref-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-xref-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-xref-conc cst)
                  (pdf-cst-xref-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-xref-entry-conc

(defun pdf-cst-xref-entry-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "xref-entry")))
  (let ((__function__ 'pdf-cst-xref-entry-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-xref-entry-conc

(defthm tree-list-listp-of-pdf-cst-xref-entry-conc
  (b* ((cstss (pdf-cst-xref-entry-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-entry-conc-match

(defthm pdf-cst-xref-entry-conc-match
  (implies (pdf-cst-matchp cst "xref-entry")
           (b* ((cstss (pdf-cst-xref-entry-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "xref-int ws xref-int ws use-marker")))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-entry-conc-of-tree-fix-cst

(defthm pdf-cst-xref-entry-conc-of-tree-fix-cst
  (equal (pdf-cst-xref-entry-conc (tree-fix cst))
         (pdf-cst-xref-entry-conc cst)))

Theorem: pdf-cst-xref-entry-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-xref-entry-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-xref-entry-conc cst)
                  (pdf-cst-xref-entry-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-xref-marker-conc

(defun pdf-cst-xref-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "xref-marker")))
  (let ((__function__ 'pdf-cst-xref-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-xref-marker-conc

(defthm tree-list-listp-of-pdf-cst-xref-marker-conc
  (b* ((cstss (pdf-cst-xref-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-marker-conc-match

(defthm pdf-cst-xref-marker-conc-match
  (implies (pdf-cst-matchp cst "xref-marker")
           (b* ((cstss (pdf-cst-xref-marker-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x78.72.65.66")))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-marker-conc-of-tree-fix-cst

(defthm pdf-cst-xref-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-xref-marker-conc (tree-fix cst))
         (pdf-cst-xref-marker-conc cst)))

Theorem: pdf-cst-xref-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-xref-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-xref-marker-conc cst)
                  (pdf-cst-xref-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-xref-int-conc

(defun pdf-cst-xref-int-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "xref-int")))
  (let ((__function__ 'pdf-cst-xref-int-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-xref-int-conc

(defthm tree-list-listp-of-pdf-cst-xref-int-conc
  (b* ((cstss (pdf-cst-xref-int-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-int-conc-match

(defthm pdf-cst-xref-int-conc-match
  (implies (pdf-cst-matchp cst "xref-int")
           (b* ((cstss (pdf-cst-xref-int-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "*digit")))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-int-conc-of-tree-fix-cst

(defthm pdf-cst-xref-int-conc-of-tree-fix-cst
  (equal (pdf-cst-xref-int-conc (tree-fix cst))
         (pdf-cst-xref-int-conc cst)))

Theorem: pdf-cst-xref-int-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-xref-int-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-xref-int-conc cst)
                  (pdf-cst-xref-int-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-trailer-conc

(defun pdf-cst-trailer-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "trailer")))
  (let ((__function__ 'pdf-cst-trailer-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-trailer-conc

(defthm tree-list-listp-of-pdf-cst-trailer-conc
  (b* ((cstss (pdf-cst-trailer-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-conc-match

(defthm pdf-cst-trailer-conc-match
 (implies
  (pdf-cst-matchp cst "trailer")
  (b* ((cstss (pdf-cst-trailer-conc cst)))
   (pdf-cst-list-list-conc-matchp
    cstss
    "trailer-marker ws dictionary ws startxref-marker ws int eof-marker")))
 :rule-classes :rewrite)

Theorem: pdf-cst-trailer-conc-of-tree-fix-cst

(defthm pdf-cst-trailer-conc-of-tree-fix-cst
  (equal (pdf-cst-trailer-conc (tree-fix cst))
         (pdf-cst-trailer-conc cst)))

Theorem: pdf-cst-trailer-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-trailer-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-trailer-conc cst)
                  (pdf-cst-trailer-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-startxref-marker-conc

(defun pdf-cst-startxref-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "startxref-marker")))
  (let ((__function__ 'pdf-cst-startxref-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-startxref-marker-conc

(defthm tree-list-listp-of-pdf-cst-startxref-marker-conc
  (b* ((cstss (pdf-cst-startxref-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-startxref-marker-conc-match

(defthm pdf-cst-startxref-marker-conc-match
  (implies (pdf-cst-matchp cst "startxref-marker")
           (b* ((cstss (pdf-cst-startxref-marker-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss "%x73.74.61.72.74.78.72.65.66")))
  :rule-classes :rewrite)

Theorem: pdf-cst-startxref-marker-conc-of-tree-fix-cst

(defthm pdf-cst-startxref-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-startxref-marker-conc (tree-fix cst))
         (pdf-cst-startxref-marker-conc cst)))

Theorem: pdf-cst-startxref-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-startxref-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-startxref-marker-conc cst)
                  (pdf-cst-startxref-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-eof-marker-conc

(defun pdf-cst-eof-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "eof-marker")))
  (let ((__function__ 'pdf-cst-eof-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-eof-marker-conc

(defthm tree-list-listp-of-pdf-cst-eof-marker-conc
  (b* ((cstss (pdf-cst-eof-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-eof-marker-conc-match

(defthm pdf-cst-eof-marker-conc-match
  (implies
       (pdf-cst-matchp cst "eof-marker")
       (b* ((cstss (pdf-cst-eof-marker-conc cst)))
         (pdf-cst-list-list-conc-matchp cstss "%x25.25.45.4F.46")))
  :rule-classes :rewrite)

Theorem: pdf-cst-eof-marker-conc-of-tree-fix-cst

(defthm pdf-cst-eof-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-eof-marker-conc (tree-fix cst))
         (pdf-cst-eof-marker-conc cst)))

Theorem: pdf-cst-eof-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-eof-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-eof-marker-conc cst)
                  (pdf-cst-eof-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-trailer-dictionary-conc

(defun pdf-cst-trailer-dictionary-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "trailer-dictionary")))
  (let ((__function__ 'pdf-cst-trailer-dictionary-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-trailer-dictionary-conc

(defthm tree-list-listp-of-pdf-cst-trailer-dictionary-conc
  (b* ((cstss (pdf-cst-trailer-dictionary-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-dictionary-conc-match

(defthm pdf-cst-trailer-dictionary-conc-match
  (implies (pdf-cst-matchp cst "trailer-dictionary")
           (b* ((cstss (pdf-cst-trailer-dictionary-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "start-dict *trailer-key-and-value end-dict")))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-dictionary-conc-of-tree-fix-cst

(defthm pdf-cst-trailer-dictionary-conc-of-tree-fix-cst
  (equal (pdf-cst-trailer-dictionary-conc (tree-fix cst))
         (pdf-cst-trailer-dictionary-conc cst)))

Theorem: pdf-cst-trailer-dictionary-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-trailer-dictionary-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-trailer-dictionary-conc cst)
                  (pdf-cst-trailer-dictionary-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-trailer-marker-conc

(defun pdf-cst-trailer-marker-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "trailer-marker")))
  (let ((__function__ 'pdf-cst-trailer-marker-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-trailer-marker-conc

(defthm tree-list-listp-of-pdf-cst-trailer-marker-conc
  (b* ((cstss (pdf-cst-trailer-marker-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-marker-conc-match

(defthm pdf-cst-trailer-marker-conc-match
 (implies
  (pdf-cst-matchp cst "trailer-marker")
  (b* ((cstss (pdf-cst-trailer-marker-conc cst)))
    (pdf-cst-list-list-conc-matchp cstss "%x74.72.61.69.6C.65.72")))
 :rule-classes :rewrite)

Theorem: pdf-cst-trailer-marker-conc-of-tree-fix-cst

(defthm pdf-cst-trailer-marker-conc-of-tree-fix-cst
  (equal (pdf-cst-trailer-marker-conc (tree-fix cst))
         (pdf-cst-trailer-marker-conc cst)))

Theorem: pdf-cst-trailer-marker-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-trailer-marker-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-trailer-marker-conc cst)
                  (pdf-cst-trailer-marker-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dictionary-conc

(defun pdf-cst-dictionary-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "dictionary")))
  (let ((__function__ 'pdf-cst-dictionary-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dictionary-conc

(defthm tree-list-listp-of-pdf-cst-dictionary-conc
  (b* ((cstss (pdf-cst-dictionary-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dictionary-conc-match

(defthm pdf-cst-dictionary-conc-match
  (implies (pdf-cst-matchp cst "dictionary")
           (b* ((cstss (pdf-cst-dictionary-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "start-dict *dict-entry end-dict")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dictionary-conc-of-tree-fix-cst

(defthm pdf-cst-dictionary-conc-of-tree-fix-cst
  (equal (pdf-cst-dictionary-conc (tree-fix cst))
         (pdf-cst-dictionary-conc cst)))

Theorem: pdf-cst-dictionary-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-dictionary-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dictionary-conc cst)
                  (pdf-cst-dictionary-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc1

(defun pdf-cst-dict-entry-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     1))))
  (let ((__function__ 'pdf-cst-dict-entry-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc1

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc1
  (b* ((cstss (pdf-cst-dict-entry-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc1-match

(defthm pdf-cst-dict-entry-conc1-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       1))
           (b* ((cstss (pdf-cst-dict-entry-conc1 cst)))
             (pdf-cst-list-list-conc-matchp cstss "type-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc1-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc1-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc1 (tree-fix cst))
         (pdf-cst-dict-entry-conc1 cst)))

Theorem: pdf-cst-dict-entry-conc1-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc1 cst)
                  (pdf-cst-dict-entry-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc2

(defun pdf-cst-dict-entry-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     2))))
  (let ((__function__ 'pdf-cst-dict-entry-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc2

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc2
  (b* ((cstss (pdf-cst-dict-entry-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc2-match

(defthm pdf-cst-dict-entry-conc2-match
  (implies
       (and (pdf-cst-matchp cst "dict-entry")
            (equal (pdf-cst-dict-entry-conc? cst)
                   2))
       (b* ((cstss (pdf-cst-dict-entry-conc2 cst)))
         (pdf-cst-list-list-conc-matchp cstss "reference-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc2-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc2-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc2 (tree-fix cst))
         (pdf-cst-dict-entry-conc2 cst)))

Theorem: pdf-cst-dict-entry-conc2-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc2 cst)
                  (pdf-cst-dict-entry-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc3

(defun pdf-cst-dict-entry-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     3))))
  (let ((__function__ 'pdf-cst-dict-entry-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc3

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc3
  (b* ((cstss (pdf-cst-dict-entry-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc3-match

(defthm pdf-cst-dict-entry-conc3-match
 (implies
   (and (pdf-cst-matchp cst "dict-entry")
        (equal (pdf-cst-dict-entry-conc? cst)
               3))
   (b* ((cstss (pdf-cst-dict-entry-conc3 cst)))
     (pdf-cst-list-list-conc-matchp cstss "reference-array-entry")))
 :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc3-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc3-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc3 (tree-fix cst))
         (pdf-cst-dict-entry-conc3 cst)))

Theorem: pdf-cst-dict-entry-conc3-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc3 cst)
                  (pdf-cst-dict-entry-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc4

(defun pdf-cst-dict-entry-conc4 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     4))))
  (let ((__function__ 'pdf-cst-dict-entry-conc4))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc4

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc4
  (b* ((cstss (pdf-cst-dict-entry-conc4 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc4-match

(defthm pdf-cst-dict-entry-conc4-match
  (implies
       (and (pdf-cst-matchp cst "dict-entry")
            (equal (pdf-cst-dict-entry-conc? cst)
                   4))
       (b* ((cstss (pdf-cst-dict-entry-conc4 cst)))
         (pdf-cst-list-list-conc-matchp cstss "rectangle-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc4-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc4-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc4 (tree-fix cst))
         (pdf-cst-dict-entry-conc4 cst)))

Theorem: pdf-cst-dict-entry-conc4-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc4-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc4 cst)
                  (pdf-cst-dict-entry-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc5

(defun pdf-cst-dict-entry-conc5 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     5))))
  (let ((__function__ 'pdf-cst-dict-entry-conc5))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc5

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc5
  (b* ((cstss (pdf-cst-dict-entry-conc5 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc5-match

(defthm pdf-cst-dict-entry-conc5-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       5))
           (b* ((cstss (pdf-cst-dict-entry-conc5 cst)))
             (pdf-cst-list-list-conc-matchp cstss "number-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc5-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc5-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc5 (tree-fix cst))
         (pdf-cst-dict-entry-conc5 cst)))

Theorem: pdf-cst-dict-entry-conc5-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc5-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc5 cst)
                  (pdf-cst-dict-entry-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc6

(defun pdf-cst-dict-entry-conc6 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     6))))
  (let ((__function__ 'pdf-cst-dict-entry-conc6))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc6

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc6
  (b* ((cstss (pdf-cst-dict-entry-conc6 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc6-match

(defthm pdf-cst-dict-entry-conc6-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       6))
           (b* ((cstss (pdf-cst-dict-entry-conc6 cst)))
             (pdf-cst-list-list-conc-matchp cstss "name-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc6-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc6-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc6 (tree-fix cst))
         (pdf-cst-dict-entry-conc6 cst)))

Theorem: pdf-cst-dict-entry-conc6-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc6-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc6 cst)
                  (pdf-cst-dict-entry-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc7

(defun pdf-cst-dict-entry-conc7 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     7))))
  (let ((__function__ 'pdf-cst-dict-entry-conc7))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc7

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc7
  (b* ((cstss (pdf-cst-dict-entry-conc7 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc7-match

(defthm pdf-cst-dict-entry-conc7-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       7))
           (b* ((cstss (pdf-cst-dict-entry-conc7 cst)))
             (pdf-cst-list-list-conc-matchp cstss "font-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc7-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc7-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc7 (tree-fix cst))
         (pdf-cst-dict-entry-conc7 cst)))

Theorem: pdf-cst-dict-entry-conc7-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc7-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc7 cst)
                  (pdf-cst-dict-entry-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc8

(defun pdf-cst-dict-entry-conc8 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     8))))
  (let ((__function__ 'pdf-cst-dict-entry-conc8))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-entry-conc8

(defthm tree-list-listp-of-pdf-cst-dict-entry-conc8
  (b* ((cstss (pdf-cst-dict-entry-conc8 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc8-match

(defthm pdf-cst-dict-entry-conc8-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       8))
           (b* ((cstss (pdf-cst-dict-entry-conc8 cst)))
             (pdf-cst-list-list-conc-matchp cstss "default-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc8-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc8-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc8 (tree-fix cst))
         (pdf-cst-dict-entry-conc8 cst)))

Theorem: pdf-cst-dict-entry-conc8-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc8-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc8 cst)
                  (pdf-cst-dict-entry-conc8 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-default-entry-conc

(defun pdf-cst-default-entry-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "default-entry")))
  (let ((__function__ 'pdf-cst-default-entry-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-default-entry-conc

(defthm tree-list-listp-of-pdf-cst-default-entry-conc
  (b* ((cstss (pdf-cst-default-entry-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-default-entry-conc-match

(defthm pdf-cst-default-entry-conc-match
 (implies
  (pdf-cst-matchp cst "default-entry")
  (b* ((cstss (pdf-cst-default-entry-conc cst)))
    (pdf-cst-list-list-conc-matchp cstss "dict-key ws dict-value")))
 :rule-classes :rewrite)

Theorem: pdf-cst-default-entry-conc-of-tree-fix-cst

(defthm pdf-cst-default-entry-conc-of-tree-fix-cst
  (equal (pdf-cst-default-entry-conc (tree-fix cst))
         (pdf-cst-default-entry-conc cst)))

Theorem: pdf-cst-default-entry-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-default-entry-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-default-entry-conc cst)
                  (pdf-cst-default-entry-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-type-entry-conc

(defun pdf-cst-type-entry-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "type-entry")))
  (let ((__function__ 'pdf-cst-type-entry-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-type-entry-conc

(defthm tree-list-listp-of-pdf-cst-type-entry-conc
  (b* ((cstss (pdf-cst-type-entry-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-type-entry-conc-match

(defthm pdf-cst-type-entry-conc-match
 (implies (pdf-cst-matchp cst "type-entry")
          (b* ((cstss (pdf-cst-type-entry-conc cst)))
            (pdf-cst-list-list-conc-matchp cstss "%s\"/Type\" name")))
 :rule-classes :rewrite)

Theorem: pdf-cst-type-entry-conc-of-tree-fix-cst

(defthm pdf-cst-type-entry-conc-of-tree-fix-cst
  (equal (pdf-cst-type-entry-conc (tree-fix cst))
         (pdf-cst-type-entry-conc cst)))

Theorem: pdf-cst-type-entry-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-type-entry-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-type-entry-conc cst)
                  (pdf-cst-type-entry-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-reference-array-entry-conc

(defun pdf-cst-reference-array-entry-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare
       (xargs :guard (pdf-cst-matchp cst "reference-array-entry")))
  (let ((__function__ 'pdf-cst-reference-array-entry-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-reference-array-entry-conc

(defthm tree-list-listp-of-pdf-cst-reference-array-entry-conc
  (b* ((cstss (pdf-cst-reference-array-entry-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-reference-array-entry-conc-match

(defthm pdf-cst-reference-array-entry-conc-match
  (implies (pdf-cst-matchp cst "reference-array-entry")
           (b* ((cstss (pdf-cst-reference-array-entry-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss "%s\"/Kids\" reference-array")))
  :rule-classes :rewrite)

Theorem: pdf-cst-reference-array-entry-conc-of-tree-fix-cst

(defthm pdf-cst-reference-array-entry-conc-of-tree-fix-cst
  (equal (pdf-cst-reference-array-entry-conc (tree-fix cst))
         (pdf-cst-reference-array-entry-conc cst)))

Theorem: pdf-cst-reference-array-entry-conc-tree-equiv-congruence-on-cst

(defthm
    pdf-cst-reference-array-entry-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-reference-array-entry-conc cst)
                  (pdf-cst-reference-array-entry-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-font-entry-conc

(defun pdf-cst-font-entry-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "font-entry")))
  (let ((__function__ 'pdf-cst-font-entry-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-font-entry-conc

(defthm tree-list-listp-of-pdf-cst-font-entry-conc
  (b* ((cstss (pdf-cst-font-entry-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-font-entry-conc-match

(defthm pdf-cst-font-entry-conc-match
 (implies (pdf-cst-matchp cst "font-entry")
          (b* ((cstss (pdf-cst-font-entry-conc cst)))
            (pdf-cst-list-list-conc-matchp cstss "%s\"/Font\" font")))
 :rule-classes :rewrite)

Theorem: pdf-cst-font-entry-conc-of-tree-fix-cst

(defthm pdf-cst-font-entry-conc-of-tree-fix-cst
  (equal (pdf-cst-font-entry-conc (tree-fix cst))
         (pdf-cst-font-entry-conc cst)))

Theorem: pdf-cst-font-entry-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-font-entry-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-font-entry-conc cst)
                  (pdf-cst-font-entry-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-font-conc

(defun pdf-cst-font-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "font")))
  (let ((__function__ 'pdf-cst-font-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-font-conc

(defthm tree-list-listp-of-pdf-cst-font-conc
  (b* ((cstss (pdf-cst-font-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-font-conc-match

(defthm pdf-cst-font-conc-match
  (implies (pdf-cst-matchp cst "font")
           (b* ((cstss (pdf-cst-font-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "start-dict name reference end-dict")))
  :rule-classes :rewrite)

Theorem: pdf-cst-font-conc-of-tree-fix-cst

(defthm pdf-cst-font-conc-of-tree-fix-cst
  (equal (pdf-cst-font-conc (tree-fix cst))
         (pdf-cst-font-conc cst)))

Theorem: pdf-cst-font-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-font-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-font-conc cst)
                  (pdf-cst-font-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-key-conc

(defun pdf-cst-dict-key-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "dict-key")))
  (let ((__function__ 'pdf-cst-dict-key-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-key-conc

(defthm tree-list-listp-of-pdf-cst-dict-key-conc
  (b* ((cstss (pdf-cst-dict-key-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-key-conc-match

(defthm pdf-cst-dict-key-conc-match
  (implies
       (pdf-cst-matchp cst "dict-key")
       (b* ((cstss (pdf-cst-dict-key-conc cst)))
         (pdf-cst-list-list-conc-matchp cstss "backslash *char")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-key-conc-of-tree-fix-cst

(defthm pdf-cst-dict-key-conc-of-tree-fix-cst
  (equal (pdf-cst-dict-key-conc (tree-fix cst))
         (pdf-cst-dict-key-conc cst)))

Theorem: pdf-cst-dict-key-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-key-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-key-conc cst)
                  (pdf-cst-dict-key-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc1

(defun pdf-cst-dict-value-conc1 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     1))))
  (let ((__function__ 'pdf-cst-dict-value-conc1))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc1

(defthm tree-list-listp-of-pdf-cst-dict-value-conc1
  (b* ((cstss (pdf-cst-dict-value-conc1 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc1-match

(defthm pdf-cst-dict-value-conc1-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       1))
           (b* ((cstss (pdf-cst-dict-value-conc1 cst)))
             (pdf-cst-list-list-conc-matchp cstss "boolean")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc1-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc1-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc1 (tree-fix cst))
         (pdf-cst-dict-value-conc1 cst)))

Theorem: pdf-cst-dict-value-conc1-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc1-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc1 cst)
                  (pdf-cst-dict-value-conc1 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc2

(defun pdf-cst-dict-value-conc2 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     2))))
  (let ((__function__ 'pdf-cst-dict-value-conc2))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc2

(defthm tree-list-listp-of-pdf-cst-dict-value-conc2
  (b* ((cstss (pdf-cst-dict-value-conc2 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc2-match

(defthm pdf-cst-dict-value-conc2-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       2))
           (b* ((cstss (pdf-cst-dict-value-conc2 cst)))
             (pdf-cst-list-list-conc-matchp cstss "number")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc2-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc2-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc2 (tree-fix cst))
         (pdf-cst-dict-value-conc2 cst)))

Theorem: pdf-cst-dict-value-conc2-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc2-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc2 cst)
                  (pdf-cst-dict-value-conc2 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc3

(defun pdf-cst-dict-value-conc3 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     3))))
  (let ((__function__ 'pdf-cst-dict-value-conc3))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc3

(defthm tree-list-listp-of-pdf-cst-dict-value-conc3
  (b* ((cstss (pdf-cst-dict-value-conc3 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc3-match

(defthm pdf-cst-dict-value-conc3-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       3))
           (b* ((cstss (pdf-cst-dict-value-conc3 cst)))
             (pdf-cst-list-list-conc-matchp cstss "name")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc3-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc3-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc3 (tree-fix cst))
         (pdf-cst-dict-value-conc3 cst)))

Theorem: pdf-cst-dict-value-conc3-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc3-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc3 cst)
                  (pdf-cst-dict-value-conc3 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc4

(defun pdf-cst-dict-value-conc4 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     4))))
  (let ((__function__ 'pdf-cst-dict-value-conc4))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc4

(defthm tree-list-listp-of-pdf-cst-dict-value-conc4
  (b* ((cstss (pdf-cst-dict-value-conc4 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc4-match

(defthm pdf-cst-dict-value-conc4-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       4))
           (b* ((cstss (pdf-cst-dict-value-conc4 cst)))
             (pdf-cst-list-list-conc-matchp cstss "array")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc4-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc4-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc4 (tree-fix cst))
         (pdf-cst-dict-value-conc4 cst)))

Theorem: pdf-cst-dict-value-conc4-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc4-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc4 cst)
                  (pdf-cst-dict-value-conc4 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc5

(defun pdf-cst-dict-value-conc5 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     5))))
  (let ((__function__ 'pdf-cst-dict-value-conc5))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc5

(defthm tree-list-listp-of-pdf-cst-dict-value-conc5
  (b* ((cstss (pdf-cst-dict-value-conc5 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc5-match

(defthm pdf-cst-dict-value-conc5-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       5))
           (b* ((cstss (pdf-cst-dict-value-conc5 cst)))
             (pdf-cst-list-list-conc-matchp cstss "dictionary")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc5-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc5-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc5 (tree-fix cst))
         (pdf-cst-dict-value-conc5 cst)))

Theorem: pdf-cst-dict-value-conc5-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc5-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc5 cst)
                  (pdf-cst-dict-value-conc5 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc6

(defun pdf-cst-dict-value-conc6 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     6))))
  (let ((__function__ 'pdf-cst-dict-value-conc6))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc6

(defthm tree-list-listp-of-pdf-cst-dict-value-conc6
  (b* ((cstss (pdf-cst-dict-value-conc6 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc6-match

(defthm pdf-cst-dict-value-conc6-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       6))
           (b* ((cstss (pdf-cst-dict-value-conc6 cst)))
             (pdf-cst-list-list-conc-matchp cstss "null")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc6-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc6-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc6 (tree-fix cst))
         (pdf-cst-dict-value-conc6 cst)))

Theorem: pdf-cst-dict-value-conc6-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc6-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc6 cst)
                  (pdf-cst-dict-value-conc6 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc7

(defun pdf-cst-dict-value-conc7 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     7))))
  (let ((__function__ 'pdf-cst-dict-value-conc7))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc7

(defthm tree-list-listp-of-pdf-cst-dict-value-conc7
  (b* ((cstss (pdf-cst-dict-value-conc7 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc7-match

(defthm pdf-cst-dict-value-conc7-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       7))
           (b* ((cstss (pdf-cst-dict-value-conc7 cst)))
             (pdf-cst-list-list-conc-matchp cstss "rectangle")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc7-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc7-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc7 (tree-fix cst))
         (pdf-cst-dict-value-conc7 cst)))

Theorem: pdf-cst-dict-value-conc7-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc7-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc7 cst)
                  (pdf-cst-dict-value-conc7 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc8

(defun pdf-cst-dict-value-conc8 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     8))))
  (let ((__function__ 'pdf-cst-dict-value-conc8))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc8

(defthm tree-list-listp-of-pdf-cst-dict-value-conc8
  (b* ((cstss (pdf-cst-dict-value-conc8 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc8-match

(defthm pdf-cst-dict-value-conc8-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       8))
           (b* ((cstss (pdf-cst-dict-value-conc8 cst)))
             (pdf-cst-list-list-conc-matchp cstss "reference")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc8-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc8-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc8 (tree-fix cst))
         (pdf-cst-dict-value-conc8 cst)))

Theorem: pdf-cst-dict-value-conc8-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc8-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc8 cst)
                  (pdf-cst-dict-value-conc8 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc9

(defun pdf-cst-dict-value-conc9 (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     9))))
  (let ((__function__ 'pdf-cst-dict-value-conc9))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-dict-value-conc9

(defthm tree-list-listp-of-pdf-cst-dict-value-conc9
  (b* ((cstss (pdf-cst-dict-value-conc9 cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc9-match

(defthm pdf-cst-dict-value-conc9-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       9))
           (b* ((cstss (pdf-cst-dict-value-conc9 cst)))
             (pdf-cst-list-list-conc-matchp cstss "string")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc9-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc9-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc9 (tree-fix cst))
         (pdf-cst-dict-value-conc9 cst)))

Theorem: pdf-cst-dict-value-conc9-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc9-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc9 cst)
                  (pdf-cst-dict-value-conc9 cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-start-dict-conc

(defun pdf-cst-start-dict-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "start-dict")))
  (let ((__function__ 'pdf-cst-start-dict-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-start-dict-conc

(defthm tree-list-listp-of-pdf-cst-start-dict-conc
  (b* ((cstss (pdf-cst-start-dict-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-start-dict-conc-match

(defthm pdf-cst-start-dict-conc-match
  (implies (pdf-cst-matchp cst "start-dict")
           (b* ((cstss (pdf-cst-start-dict-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x3C.3C")))
  :rule-classes :rewrite)

Theorem: pdf-cst-start-dict-conc-of-tree-fix-cst

(defthm pdf-cst-start-dict-conc-of-tree-fix-cst
  (equal (pdf-cst-start-dict-conc (tree-fix cst))
         (pdf-cst-start-dict-conc cst)))

Theorem: pdf-cst-start-dict-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-start-dict-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-start-dict-conc cst)
                  (pdf-cst-start-dict-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-end-dict-conc

(defun pdf-cst-end-dict-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "end-dict")))
  (let ((__function__ 'pdf-cst-end-dict-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-end-dict-conc

(defthm tree-list-listp-of-pdf-cst-end-dict-conc
  (b* ((cstss (pdf-cst-end-dict-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-end-dict-conc-match

(defthm pdf-cst-end-dict-conc-match
  (implies (pdf-cst-matchp cst "end-dict")
           (b* ((cstss (pdf-cst-end-dict-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x3E.3E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-end-dict-conc-of-tree-fix-cst

(defthm pdf-cst-end-dict-conc-of-tree-fix-cst
  (equal (pdf-cst-end-dict-conc (tree-fix cst))
         (pdf-cst-end-dict-conc cst)))

Theorem: pdf-cst-end-dict-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-end-dict-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-end-dict-conc cst)
                  (pdf-cst-end-dict-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-ws-conc

(defun pdf-cst-ws-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "ws")))
  (let ((__function__ 'pdf-cst-ws-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-ws-conc

(defthm tree-list-listp-of-pdf-cst-ws-conc
  (b* ((cstss (pdf-cst-ws-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-ws-conc-match

(defthm pdf-cst-ws-conc-match
  (implies (pdf-cst-matchp cst "ws")
           (b* ((cstss (pdf-cst-ws-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "*( %x0 / %x9 / %xA / %xC / %xD / %x20 )")))
  :rule-classes :rewrite)

Theorem: pdf-cst-ws-conc-of-tree-fix-cst

(defthm pdf-cst-ws-conc-of-tree-fix-cst
  (equal (pdf-cst-ws-conc (tree-fix cst))
         (pdf-cst-ws-conc cst)))

Theorem: pdf-cst-ws-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-ws-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-ws-conc cst)
                  (pdf-cst-ws-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-digit1-9-conc

(defun pdf-cst-digit1-9-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "digit1-9")))
  (let ((__function__ 'pdf-cst-digit1-9-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-digit1-9-conc

(defthm tree-list-listp-of-pdf-cst-digit1-9-conc
  (b* ((cstss (pdf-cst-digit1-9-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit1-9-conc-match

(defthm pdf-cst-digit1-9-conc-match
  (implies (pdf-cst-matchp cst "digit1-9")
           (b* ((cstss (pdf-cst-digit1-9-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x31-39")))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit1-9-conc-of-tree-fix-cst

(defthm pdf-cst-digit1-9-conc-of-tree-fix-cst
  (equal (pdf-cst-digit1-9-conc (tree-fix cst))
         (pdf-cst-digit1-9-conc cst)))

Theorem: pdf-cst-digit1-9-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-digit1-9-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-digit1-9-conc cst)
                  (pdf-cst-digit1-9-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-digit-conc

(defun pdf-cst-digit-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "digit")))
  (let ((__function__ 'pdf-cst-digit-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-digit-conc

(defthm tree-list-listp-of-pdf-cst-digit-conc
  (b* ((cstss (pdf-cst-digit-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit-conc-match

(defthm pdf-cst-digit-conc-match
  (implies (pdf-cst-matchp cst "digit")
           (b* ((cstss (pdf-cst-digit-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x30-39")))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit-conc-of-tree-fix-cst

(defthm pdf-cst-digit-conc-of-tree-fix-cst
  (equal (pdf-cst-digit-conc (tree-fix cst))
         (pdf-cst-digit-conc cst)))

Theorem: pdf-cst-digit-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-digit-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-digit-conc cst)
                  (pdf-cst-digit-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-array-conc

(defun pdf-cst-array-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "array")))
  (let ((__function__ 'pdf-cst-array-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-array-conc

(defthm tree-list-listp-of-pdf-cst-array-conc
  (b* ((cstss (pdf-cst-array-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-array-conc-match

(defthm pdf-cst-array-conc-match
  (implies (pdf-cst-matchp cst "array")
           (b* ((cstss (pdf-cst-array-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "left-bracket *char right-bracket")))
  :rule-classes :rewrite)

Theorem: pdf-cst-array-conc-of-tree-fix-cst

(defthm pdf-cst-array-conc-of-tree-fix-cst
  (equal (pdf-cst-array-conc (tree-fix cst))
         (pdf-cst-array-conc cst)))

Theorem: pdf-cst-array-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-array-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-array-conc cst)
                  (pdf-cst-array-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-reference-array-conc

(defun pdf-cst-reference-array-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "reference-array")))
  (let ((__function__ 'pdf-cst-reference-array-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-reference-array-conc

(defthm tree-list-listp-of-pdf-cst-reference-array-conc
  (b* ((cstss (pdf-cst-reference-array-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-reference-array-conc-match

(defthm pdf-cst-reference-array-conc-match
  (implies (pdf-cst-matchp cst "reference-array")
           (b* ((cstss (pdf-cst-reference-array-conc cst)))
             (pdf-cst-list-list-conc-matchp
                  cstss
                  "left-bracket *reference right-bracket")))
  :rule-classes :rewrite)

Theorem: pdf-cst-reference-array-conc-of-tree-fix-cst

(defthm pdf-cst-reference-array-conc-of-tree-fix-cst
  (equal (pdf-cst-reference-array-conc (tree-fix cst))
         (pdf-cst-reference-array-conc cst)))

Theorem: pdf-cst-reference-array-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-reference-array-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-reference-array-conc cst)
                  (pdf-cst-reference-array-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-reference-conc

(defun pdf-cst-reference-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "reference")))
  (let ((__function__ 'pdf-cst-reference-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-reference-conc

(defthm tree-list-listp-of-pdf-cst-reference-conc
  (b* ((cstss (pdf-cst-reference-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-reference-conc-match

(defthm pdf-cst-reference-conc-match
 (implies
      (pdf-cst-matchp cst "reference")
      (b* ((cstss (pdf-cst-reference-conc cst)))
        (pdf-cst-list-list-conc-matchp cstss "int %x20 zero %x52")))
 :rule-classes :rewrite)

Theorem: pdf-cst-reference-conc-of-tree-fix-cst

(defthm pdf-cst-reference-conc-of-tree-fix-cst
  (equal (pdf-cst-reference-conc (tree-fix cst))
         (pdf-cst-reference-conc cst)))

Theorem: pdf-cst-reference-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-reference-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-reference-conc cst)
                  (pdf-cst-reference-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-rectangle-conc

(defun pdf-cst-rectangle-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "rectangle")))
  (let ((__function__ 'pdf-cst-rectangle-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-rectangle-conc

(defthm tree-list-listp-of-pdf-cst-rectangle-conc
  (b* ((cstss (pdf-cst-rectangle-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-rectangle-conc-match

(defthm pdf-cst-rectangle-conc-match
 (implies
  (pdf-cst-matchp cst "rectangle")
  (b* ((cstss (pdf-cst-rectangle-conc cst)))
    (pdf-cst-list-list-conc-matchp
         cstss
         "left-bracket number number number number right-bracket")))
 :rule-classes :rewrite)

Theorem: pdf-cst-rectangle-conc-of-tree-fix-cst

(defthm pdf-cst-rectangle-conc-of-tree-fix-cst
  (equal (pdf-cst-rectangle-conc (tree-fix cst))
         (pdf-cst-rectangle-conc cst)))

Theorem: pdf-cst-rectangle-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-rectangle-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-rectangle-conc cst)
                  (pdf-cst-rectangle-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-left-bracket-conc

(defun pdf-cst-left-bracket-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "left-bracket")))
  (let ((__function__ 'pdf-cst-left-bracket-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-left-bracket-conc

(defthm tree-list-listp-of-pdf-cst-left-bracket-conc
  (b* ((cstss (pdf-cst-left-bracket-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-left-bracket-conc-match

(defthm pdf-cst-left-bracket-conc-match
  (implies (pdf-cst-matchp cst "left-bracket")
           (b* ((cstss (pdf-cst-left-bracket-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x5B")))
  :rule-classes :rewrite)

Theorem: pdf-cst-left-bracket-conc-of-tree-fix-cst

(defthm pdf-cst-left-bracket-conc-of-tree-fix-cst
  (equal (pdf-cst-left-bracket-conc (tree-fix cst))
         (pdf-cst-left-bracket-conc cst)))

Theorem: pdf-cst-left-bracket-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-left-bracket-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-left-bracket-conc cst)
                  (pdf-cst-left-bracket-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-right-bracket-conc

(defun pdf-cst-right-bracket-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "right-bracket")))
  (let ((__function__ 'pdf-cst-right-bracket-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-right-bracket-conc

(defthm tree-list-listp-of-pdf-cst-right-bracket-conc
  (b* ((cstss (pdf-cst-right-bracket-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-right-bracket-conc-match

(defthm pdf-cst-right-bracket-conc-match
  (implies (pdf-cst-matchp cst "right-bracket")
           (b* ((cstss (pdf-cst-right-bracket-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x5D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-right-bracket-conc-of-tree-fix-cst

(defthm pdf-cst-right-bracket-conc-of-tree-fix-cst
  (equal (pdf-cst-right-bracket-conc (tree-fix cst))
         (pdf-cst-right-bracket-conc cst)))

Theorem: pdf-cst-right-bracket-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-right-bracket-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-right-bracket-conc cst)
                  (pdf-cst-right-bracket-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-null-conc

(defun pdf-cst-null-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "null")))
  (let ((__function__ 'pdf-cst-null-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-null-conc

(defthm tree-list-listp-of-pdf-cst-null-conc
  (b* ((cstss (pdf-cst-null-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-null-conc-match

(defthm pdf-cst-null-conc-match
  (implies (pdf-cst-matchp cst "null")
           (b* ((cstss (pdf-cst-null-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%s\"null\"")))
  :rule-classes :rewrite)

Theorem: pdf-cst-null-conc-of-tree-fix-cst

(defthm pdf-cst-null-conc-of-tree-fix-cst
  (equal (pdf-cst-null-conc (tree-fix cst))
         (pdf-cst-null-conc cst)))

Theorem: pdf-cst-null-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-null-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-null-conc cst)
                  (pdf-cst-null-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-name-conc

(defun pdf-cst-name-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "name")))
  (let ((__function__ 'pdf-cst-name-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-name-conc

(defthm tree-list-listp-of-pdf-cst-name-conc
  (b* ((cstss (pdf-cst-name-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-conc-match

(defthm pdf-cst-name-conc-match
  (implies
       (pdf-cst-matchp cst "name")
       (b* ((cstss (pdf-cst-name-conc cst)))
         (pdf-cst-list-list-conc-matchp cstss "slash name-char")))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-conc-of-tree-fix-cst

(defthm pdf-cst-name-conc-of-tree-fix-cst
  (equal (pdf-cst-name-conc (tree-fix cst))
         (pdf-cst-name-conc cst)))

Theorem: pdf-cst-name-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-name-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-name-conc cst)
                  (pdf-cst-name-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-name-char-conc

(defun pdf-cst-name-char-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "name-char")))
  (let ((__function__ 'pdf-cst-name-char-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-name-char-conc

(defthm tree-list-listp-of-pdf-cst-name-char-conc
  (b* ((cstss (pdf-cst-name-char-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-char-conc-match

(defthm pdf-cst-name-char-conc-match
  (implies (pdf-cst-matchp cst "name-char")
           (b* ((cstss (pdf-cst-name-char-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x20-7E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-char-conc-of-tree-fix-cst

(defthm pdf-cst-name-char-conc-of-tree-fix-cst
  (equal (pdf-cst-name-char-conc (tree-fix cst))
         (pdf-cst-name-char-conc cst)))

Theorem: pdf-cst-name-char-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-name-char-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-name-char-conc cst)
                  (pdf-cst-name-char-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-real-conc

(defun pdf-cst-real-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "real")))
  (let ((__function__ 'pdf-cst-real-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-real-conc

(defthm tree-list-listp-of-pdf-cst-real-conc
  (b* ((cstss (pdf-cst-real-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-real-conc-match

(defthm pdf-cst-real-conc-match
 (implies (pdf-cst-matchp cst "real")
          (b* ((cstss (pdf-cst-real-conc cst)))
            (pdf-cst-list-list-conc-matchp cstss "int period int")))
 :rule-classes :rewrite)

Theorem: pdf-cst-real-conc-of-tree-fix-cst

(defthm pdf-cst-real-conc-of-tree-fix-cst
  (equal (pdf-cst-real-conc (tree-fix cst))
         (pdf-cst-real-conc cst)))

Theorem: pdf-cst-real-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-real-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-real-conc cst)
                  (pdf-cst-real-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-plus-conc

(defun pdf-cst-plus-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "plus")))
  (let ((__function__ 'pdf-cst-plus-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-plus-conc

(defthm tree-list-listp-of-pdf-cst-plus-conc
  (b* ((cstss (pdf-cst-plus-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-plus-conc-match

(defthm pdf-cst-plus-conc-match
  (implies (pdf-cst-matchp cst "plus")
           (b* ((cstss (pdf-cst-plus-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x2B")))
  :rule-classes :rewrite)

Theorem: pdf-cst-plus-conc-of-tree-fix-cst

(defthm pdf-cst-plus-conc-of-tree-fix-cst
  (equal (pdf-cst-plus-conc (tree-fix cst))
         (pdf-cst-plus-conc cst)))

Theorem: pdf-cst-plus-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-plus-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-plus-conc cst)
                  (pdf-cst-plus-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-minus-conc

(defun pdf-cst-minus-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "minus")))
  (let ((__function__ 'pdf-cst-minus-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-minus-conc

(defthm tree-list-listp-of-pdf-cst-minus-conc
  (b* ((cstss (pdf-cst-minus-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-minus-conc-match

(defthm pdf-cst-minus-conc-match
  (implies (pdf-cst-matchp cst "minus")
           (b* ((cstss (pdf-cst-minus-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x2D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-minus-conc-of-tree-fix-cst

(defthm pdf-cst-minus-conc-of-tree-fix-cst
  (equal (pdf-cst-minus-conc (tree-fix cst))
         (pdf-cst-minus-conc cst)))

Theorem: pdf-cst-minus-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-minus-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-minus-conc cst)
                  (pdf-cst-minus-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-slash-conc

(defun pdf-cst-slash-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "slash")))
  (let ((__function__ 'pdf-cst-slash-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-slash-conc

(defthm tree-list-listp-of-pdf-cst-slash-conc
  (b* ((cstss (pdf-cst-slash-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-slash-conc-match

(defthm pdf-cst-slash-conc-match
  (implies (pdf-cst-matchp cst "slash")
           (b* ((cstss (pdf-cst-slash-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x2F")))
  :rule-classes :rewrite)

Theorem: pdf-cst-slash-conc-of-tree-fix-cst

(defthm pdf-cst-slash-conc-of-tree-fix-cst
  (equal (pdf-cst-slash-conc (tree-fix cst))
         (pdf-cst-slash-conc cst)))

Theorem: pdf-cst-slash-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-slash-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-slash-conc cst)
                  (pdf-cst-slash-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-backslash-conc

(defun pdf-cst-backslash-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "backslash")))
  (let ((__function__ 'pdf-cst-backslash-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-backslash-conc

(defthm tree-list-listp-of-pdf-cst-backslash-conc
  (b* ((cstss (pdf-cst-backslash-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-backslash-conc-match

(defthm pdf-cst-backslash-conc-match
  (implies (pdf-cst-matchp cst "backslash")
           (b* ((cstss (pdf-cst-backslash-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x5C")))
  :rule-classes :rewrite)

Theorem: pdf-cst-backslash-conc-of-tree-fix-cst

(defthm pdf-cst-backslash-conc-of-tree-fix-cst
  (equal (pdf-cst-backslash-conc (tree-fix cst))
         (pdf-cst-backslash-conc cst)))

Theorem: pdf-cst-backslash-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-backslash-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-backslash-conc cst)
                  (pdf-cst-backslash-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-zero-conc

(defun pdf-cst-zero-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "zero")))
  (let ((__function__ 'pdf-cst-zero-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-zero-conc

(defthm tree-list-listp-of-pdf-cst-zero-conc
  (b* ((cstss (pdf-cst-zero-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-zero-conc-match

(defthm pdf-cst-zero-conc-match
  (implies (pdf-cst-matchp cst "zero")
           (b* ((cstss (pdf-cst-zero-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x30")))
  :rule-classes :rewrite)

Theorem: pdf-cst-zero-conc-of-tree-fix-cst

(defthm pdf-cst-zero-conc-of-tree-fix-cst
  (equal (pdf-cst-zero-conc (tree-fix cst))
         (pdf-cst-zero-conc cst)))

Theorem: pdf-cst-zero-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-zero-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-zero-conc cst)
                  (pdf-cst-zero-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-string-conc

(defun pdf-cst-string-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "string")))
  (let ((__function__ 'pdf-cst-string-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-string-conc

(defthm tree-list-listp-of-pdf-cst-string-conc
  (b* ((cstss (pdf-cst-string-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-string-conc-match

(defthm pdf-cst-string-conc-match
  (implies (pdf-cst-matchp cst "string")
           (b* ((cstss (pdf-cst-string-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "*char")))
  :rule-classes :rewrite)

Theorem: pdf-cst-string-conc-of-tree-fix-cst

(defthm pdf-cst-string-conc-of-tree-fix-cst
  (equal (pdf-cst-string-conc (tree-fix cst))
         (pdf-cst-string-conc cst)))

Theorem: pdf-cst-string-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-string-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-string-conc cst)
                  (pdf-cst-string-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-period-conc

(defun pdf-cst-period-conc (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "period")))
  (let ((__function__ 'pdf-cst-period-conc))
    (declare (ignorable __function__))
    (tree-nonleaf->branches cst)))

Theorem: tree-list-listp-of-pdf-cst-period-conc

(defthm tree-list-listp-of-pdf-cst-period-conc
  (b* ((cstss (pdf-cst-period-conc cst)))
    (tree-list-listp cstss))
  :rule-classes :rewrite)

Theorem: pdf-cst-period-conc-match

(defthm pdf-cst-period-conc-match
  (implies (pdf-cst-matchp cst "period")
           (b* ((cstss (pdf-cst-period-conc cst)))
             (pdf-cst-list-list-conc-matchp cstss "%x2E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-period-conc-of-tree-fix-cst

(defthm pdf-cst-period-conc-of-tree-fix-cst
  (equal (pdf-cst-period-conc (tree-fix cst))
         (pdf-cst-period-conc cst)))

Theorem: pdf-cst-period-conc-tree-equiv-congruence-on-cst

(defthm pdf-cst-period-conc-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-period-conc cst)
                  (pdf-cst-period-conc cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-pdf-marker-conc-rep

(defun pdf-cst-pdf-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "pdf-marker")))
  (let ((__function__ 'pdf-cst-pdf-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-pdf-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-pdf-marker-conc-rep

(defthm tree-listp-of-pdf-cst-pdf-marker-conc-rep
  (b* ((csts (pdf-cst-pdf-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-marker-conc-rep-match

(defthm pdf-cst-pdf-marker-conc-rep-match
  (implies (pdf-cst-matchp cst "pdf-marker")
           (b* ((csts (pdf-cst-pdf-marker-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x25.50.44.46.45")))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-pdf-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-pdf-marker-conc-rep (tree-fix cst))
         (pdf-cst-pdf-marker-conc-rep cst)))

Theorem: pdf-cst-pdf-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-pdf-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-pdf-marker-conc-rep cst)
                  (pdf-cst-pdf-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-obj-marker-conc-rep

(defun pdf-cst-obj-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "obj-marker")))
  (let ((__function__ 'pdf-cst-obj-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-obj-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-obj-marker-conc-rep

(defthm tree-listp-of-pdf-cst-obj-marker-conc-rep
  (b* ((csts (pdf-cst-obj-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-obj-marker-conc-rep-match

(defthm pdf-cst-obj-marker-conc-rep-match
  (implies (pdf-cst-matchp cst "obj-marker")
           (b* ((csts (pdf-cst-obj-marker-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x6F.62.6A")))
  :rule-classes :rewrite)

Theorem: pdf-cst-obj-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-obj-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-obj-marker-conc-rep (tree-fix cst))
         (pdf-cst-obj-marker-conc-rep cst)))

Theorem: pdf-cst-obj-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-obj-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-obj-marker-conc-rep cst)
                  (pdf-cst-obj-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-endobj-marker-conc-rep

(defun pdf-cst-endobj-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "endobj-marker")))
  (let ((__function__ 'pdf-cst-endobj-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-endobj-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-endobj-marker-conc-rep

(defthm tree-listp-of-pdf-cst-endobj-marker-conc-rep
  (b* ((csts (pdf-cst-endobj-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-endobj-marker-conc-rep-match

(defthm pdf-cst-endobj-marker-conc-rep-match
  (implies (pdf-cst-matchp cst "endobj-marker")
           (b* ((csts (pdf-cst-endobj-marker-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x65.6E.64.6F.62.6A")))
  :rule-classes :rewrite)

Theorem: pdf-cst-endobj-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-endobj-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-endobj-marker-conc-rep (tree-fix cst))
         (pdf-cst-endobj-marker-conc-rep cst)))

Theorem: pdf-cst-endobj-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-endobj-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-endobj-marker-conc-rep cst)
                  (pdf-cst-endobj-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-stream-marker-conc-rep

(defun pdf-cst-stream-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "stream-marker")))
  (let ((__function__ 'pdf-cst-stream-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-stream-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-stream-marker-conc-rep

(defthm tree-listp-of-pdf-cst-stream-marker-conc-rep
  (b* ((csts (pdf-cst-stream-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-marker-conc-rep-match

(defthm pdf-cst-stream-marker-conc-rep-match
  (implies (pdf-cst-matchp cst "stream-marker")
           (b* ((csts (pdf-cst-stream-marker-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x73.74.72.65.61.6D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-stream-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-stream-marker-conc-rep (tree-fix cst))
         (pdf-cst-stream-marker-conc-rep cst)))

Theorem: pdf-cst-stream-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-stream-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-stream-marker-conc-rep cst)
                  (pdf-cst-stream-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-endstream-marker-conc-rep

(defun pdf-cst-endstream-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "endstream-marker")))
  (let ((__function__ 'pdf-cst-endstream-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0
                        (pdf-cst-endstream-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-endstream-marker-conc-rep

(defthm tree-listp-of-pdf-cst-endstream-marker-conc-rep
  (b* ((csts (pdf-cst-endstream-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-endstream-marker-conc-rep-match

(defthm pdf-cst-endstream-marker-conc-rep-match
 (implies
   (pdf-cst-matchp cst "endstream-marker")
   (b* ((csts (pdf-cst-endstream-marker-conc-rep cst)))
     (pdf-cst-list-rep-matchp csts "%x65.6E.64.73.74.72.65.61.6D")))
 :rule-classes :rewrite)

Theorem: pdf-cst-endstream-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-endstream-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-endstream-marker-conc-rep (tree-fix cst))
         (pdf-cst-endstream-marker-conc-rep cst)))

Theorem: pdf-cst-endstream-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-endstream-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-endstream-marker-conc-rep cst)
                  (pdf-cst-endstream-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-xref-marker-conc-rep

(defun pdf-cst-xref-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "xref-marker")))
  (let ((__function__ 'pdf-cst-xref-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-xref-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-xref-marker-conc-rep

(defthm tree-listp-of-pdf-cst-xref-marker-conc-rep
  (b* ((csts (pdf-cst-xref-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-marker-conc-rep-match

(defthm pdf-cst-xref-marker-conc-rep-match
  (implies (pdf-cst-matchp cst "xref-marker")
           (b* ((csts (pdf-cst-xref-marker-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x78.72.65.66")))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-xref-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-xref-marker-conc-rep (tree-fix cst))
         (pdf-cst-xref-marker-conc-rep cst)))

Theorem: pdf-cst-xref-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-xref-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-xref-marker-conc-rep cst)
                  (pdf-cst-xref-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-startxref-marker-conc-rep

(defun pdf-cst-startxref-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "startxref-marker")))
  (let ((__function__ 'pdf-cst-startxref-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0
                        (pdf-cst-startxref-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-startxref-marker-conc-rep

(defthm tree-listp-of-pdf-cst-startxref-marker-conc-rep
  (b* ((csts (pdf-cst-startxref-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-startxref-marker-conc-rep-match

(defthm pdf-cst-startxref-marker-conc-rep-match
 (implies
   (pdf-cst-matchp cst "startxref-marker")
   (b* ((csts (pdf-cst-startxref-marker-conc-rep cst)))
     (pdf-cst-list-rep-matchp csts "%x73.74.61.72.74.78.72.65.66")))
 :rule-classes :rewrite)

Theorem: pdf-cst-startxref-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-startxref-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-startxref-marker-conc-rep (tree-fix cst))
         (pdf-cst-startxref-marker-conc-rep cst)))

Theorem: pdf-cst-startxref-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-startxref-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-startxref-marker-conc-rep cst)
                  (pdf-cst-startxref-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-eof-marker-conc-rep

(defun pdf-cst-eof-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "eof-marker")))
  (let ((__function__ 'pdf-cst-eof-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-eof-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-eof-marker-conc-rep

(defthm tree-listp-of-pdf-cst-eof-marker-conc-rep
  (b* ((csts (pdf-cst-eof-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-eof-marker-conc-rep-match

(defthm pdf-cst-eof-marker-conc-rep-match
  (implies (pdf-cst-matchp cst "eof-marker")
           (b* ((csts (pdf-cst-eof-marker-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x25.25.45.4F.46")))
  :rule-classes :rewrite)

Theorem: pdf-cst-eof-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-eof-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-eof-marker-conc-rep (tree-fix cst))
         (pdf-cst-eof-marker-conc-rep cst)))

Theorem: pdf-cst-eof-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-eof-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-eof-marker-conc-rep cst)
                  (pdf-cst-eof-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-trailer-marker-conc-rep

(defun pdf-cst-trailer-marker-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "trailer-marker")))
  (let ((__function__ 'pdf-cst-trailer-marker-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-trailer-marker-conc cst)))))

Theorem: tree-listp-of-pdf-cst-trailer-marker-conc-rep

(defthm tree-listp-of-pdf-cst-trailer-marker-conc-rep
  (b* ((csts (pdf-cst-trailer-marker-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-marker-conc-rep-match

(defthm pdf-cst-trailer-marker-conc-rep-match
  (implies
       (pdf-cst-matchp cst "trailer-marker")
       (b* ((csts (pdf-cst-trailer-marker-conc-rep cst)))
         (pdf-cst-list-rep-matchp csts "%x74.72.61.69.6C.65.72")))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-marker-conc-rep-of-tree-fix-cst

(defthm pdf-cst-trailer-marker-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-trailer-marker-conc-rep (tree-fix cst))
         (pdf-cst-trailer-marker-conc-rep cst)))

Theorem: pdf-cst-trailer-marker-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-trailer-marker-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-trailer-marker-conc-rep cst)
                  (pdf-cst-trailer-marker-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc1-rep

(defun pdf-cst-dict-entry-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     1))))
  (let ((__function__ 'pdf-cst-dict-entry-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc1 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc1-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc1-rep
  (b* ((csts (pdf-cst-dict-entry-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc1-rep-match

(defthm pdf-cst-dict-entry-conc1-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       1))
           (b* ((csts (pdf-cst-dict-entry-conc1-rep cst)))
             (pdf-cst-list-rep-matchp csts "type-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc1-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc1-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc1-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc1-rep cst)))

Theorem: pdf-cst-dict-entry-conc1-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc1-rep cst)
                  (pdf-cst-dict-entry-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc2-rep

(defun pdf-cst-dict-entry-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     2))))
  (let ((__function__ 'pdf-cst-dict-entry-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc2 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc2-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc2-rep
  (b* ((csts (pdf-cst-dict-entry-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc2-rep-match

(defthm pdf-cst-dict-entry-conc2-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       2))
           (b* ((csts (pdf-cst-dict-entry-conc2-rep cst)))
             (pdf-cst-list-rep-matchp csts "reference-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc2-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc2-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc2-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc2-rep cst)))

Theorem: pdf-cst-dict-entry-conc2-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc2-rep cst)
                  (pdf-cst-dict-entry-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc3-rep

(defun pdf-cst-dict-entry-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     3))))
  (let ((__function__ 'pdf-cst-dict-entry-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc3 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc3-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc3-rep
  (b* ((csts (pdf-cst-dict-entry-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc3-rep-match

(defthm pdf-cst-dict-entry-conc3-rep-match
 (implies (and (pdf-cst-matchp cst "dict-entry")
               (equal (pdf-cst-dict-entry-conc? cst)
                      3))
          (b* ((csts (pdf-cst-dict-entry-conc3-rep cst)))
            (pdf-cst-list-rep-matchp csts "reference-array-entry")))
 :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc3-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc3-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc3-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc3-rep cst)))

Theorem: pdf-cst-dict-entry-conc3-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc3-rep cst)
                  (pdf-cst-dict-entry-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc4-rep

(defun pdf-cst-dict-entry-conc4-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     4))))
  (let ((__function__ 'pdf-cst-dict-entry-conc4-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc4 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc4-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc4-rep
  (b* ((csts (pdf-cst-dict-entry-conc4-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc4-rep-match

(defthm pdf-cst-dict-entry-conc4-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       4))
           (b* ((csts (pdf-cst-dict-entry-conc4-rep cst)))
             (pdf-cst-list-rep-matchp csts "rectangle-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc4-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc4-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc4-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc4-rep cst)))

Theorem: pdf-cst-dict-entry-conc4-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc4-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc4-rep cst)
                  (pdf-cst-dict-entry-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc5-rep

(defun pdf-cst-dict-entry-conc5-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     5))))
  (let ((__function__ 'pdf-cst-dict-entry-conc5-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc5 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc5-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc5-rep
  (b* ((csts (pdf-cst-dict-entry-conc5-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc5-rep-match

(defthm pdf-cst-dict-entry-conc5-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       5))
           (b* ((csts (pdf-cst-dict-entry-conc5-rep cst)))
             (pdf-cst-list-rep-matchp csts "number-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc5-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc5-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc5-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc5-rep cst)))

Theorem: pdf-cst-dict-entry-conc5-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc5-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc5-rep cst)
                  (pdf-cst-dict-entry-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc6-rep

(defun pdf-cst-dict-entry-conc6-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     6))))
  (let ((__function__ 'pdf-cst-dict-entry-conc6-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc6 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc6-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc6-rep
  (b* ((csts (pdf-cst-dict-entry-conc6-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc6-rep-match

(defthm pdf-cst-dict-entry-conc6-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       6))
           (b* ((csts (pdf-cst-dict-entry-conc6-rep cst)))
             (pdf-cst-list-rep-matchp csts "name-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc6-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc6-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc6-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc6-rep cst)))

Theorem: pdf-cst-dict-entry-conc6-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc6-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc6-rep cst)
                  (pdf-cst-dict-entry-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc7-rep

(defun pdf-cst-dict-entry-conc7-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     7))))
  (let ((__function__ 'pdf-cst-dict-entry-conc7-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc7 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc7-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc7-rep
  (b* ((csts (pdf-cst-dict-entry-conc7-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc7-rep-match

(defthm pdf-cst-dict-entry-conc7-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       7))
           (b* ((csts (pdf-cst-dict-entry-conc7-rep cst)))
             (pdf-cst-list-rep-matchp csts "font-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc7-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc7-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc7-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc7-rep cst)))

Theorem: pdf-cst-dict-entry-conc7-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc7-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc7-rep cst)
                  (pdf-cst-dict-entry-conc7-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc8-rep

(defun pdf-cst-dict-entry-conc8-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     8))))
  (let ((__function__ 'pdf-cst-dict-entry-conc8-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-entry-conc8 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-entry-conc8-rep

(defthm tree-listp-of-pdf-cst-dict-entry-conc8-rep
  (b* ((csts (pdf-cst-dict-entry-conc8-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc8-rep-match

(defthm pdf-cst-dict-entry-conc8-rep-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       8))
           (b* ((csts (pdf-cst-dict-entry-conc8-rep cst)))
             (pdf-cst-list-rep-matchp csts "default-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc8-rep-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc8-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc8-rep (tree-fix cst))
         (pdf-cst-dict-entry-conc8-rep cst)))

Theorem: pdf-cst-dict-entry-conc8-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-entry-conc8-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc8-rep cst)
                  (pdf-cst-dict-entry-conc8-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc1-rep

(defun pdf-cst-dict-value-conc1-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     1))))
  (let ((__function__ 'pdf-cst-dict-value-conc1-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc1 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc1-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc1-rep
  (b* ((csts (pdf-cst-dict-value-conc1-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc1-rep-match

(defthm pdf-cst-dict-value-conc1-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       1))
           (b* ((csts (pdf-cst-dict-value-conc1-rep cst)))
             (pdf-cst-list-rep-matchp csts "boolean")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc1-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc1-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc1-rep (tree-fix cst))
         (pdf-cst-dict-value-conc1-rep cst)))

Theorem: pdf-cst-dict-value-conc1-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc1-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc1-rep cst)
                  (pdf-cst-dict-value-conc1-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc2-rep

(defun pdf-cst-dict-value-conc2-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     2))))
  (let ((__function__ 'pdf-cst-dict-value-conc2-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc2 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc2-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc2-rep
  (b* ((csts (pdf-cst-dict-value-conc2-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc2-rep-match

(defthm pdf-cst-dict-value-conc2-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       2))
           (b* ((csts (pdf-cst-dict-value-conc2-rep cst)))
             (pdf-cst-list-rep-matchp csts "number")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc2-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc2-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc2-rep (tree-fix cst))
         (pdf-cst-dict-value-conc2-rep cst)))

Theorem: pdf-cst-dict-value-conc2-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc2-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc2-rep cst)
                  (pdf-cst-dict-value-conc2-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc3-rep

(defun pdf-cst-dict-value-conc3-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     3))))
  (let ((__function__ 'pdf-cst-dict-value-conc3-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc3 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc3-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc3-rep
  (b* ((csts (pdf-cst-dict-value-conc3-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc3-rep-match

(defthm pdf-cst-dict-value-conc3-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       3))
           (b* ((csts (pdf-cst-dict-value-conc3-rep cst)))
             (pdf-cst-list-rep-matchp csts "name")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc3-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc3-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc3-rep (tree-fix cst))
         (pdf-cst-dict-value-conc3-rep cst)))

Theorem: pdf-cst-dict-value-conc3-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc3-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc3-rep cst)
                  (pdf-cst-dict-value-conc3-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc4-rep

(defun pdf-cst-dict-value-conc4-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     4))))
  (let ((__function__ 'pdf-cst-dict-value-conc4-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc4 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc4-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc4-rep
  (b* ((csts (pdf-cst-dict-value-conc4-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc4-rep-match

(defthm pdf-cst-dict-value-conc4-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       4))
           (b* ((csts (pdf-cst-dict-value-conc4-rep cst)))
             (pdf-cst-list-rep-matchp csts "array")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc4-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc4-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc4-rep (tree-fix cst))
         (pdf-cst-dict-value-conc4-rep cst)))

Theorem: pdf-cst-dict-value-conc4-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc4-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc4-rep cst)
                  (pdf-cst-dict-value-conc4-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc5-rep

(defun pdf-cst-dict-value-conc5-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     5))))
  (let ((__function__ 'pdf-cst-dict-value-conc5-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc5 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc5-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc5-rep
  (b* ((csts (pdf-cst-dict-value-conc5-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc5-rep-match

(defthm pdf-cst-dict-value-conc5-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       5))
           (b* ((csts (pdf-cst-dict-value-conc5-rep cst)))
             (pdf-cst-list-rep-matchp csts "dictionary")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc5-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc5-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc5-rep (tree-fix cst))
         (pdf-cst-dict-value-conc5-rep cst)))

Theorem: pdf-cst-dict-value-conc5-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc5-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc5-rep cst)
                  (pdf-cst-dict-value-conc5-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc6-rep

(defun pdf-cst-dict-value-conc6-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     6))))
  (let ((__function__ 'pdf-cst-dict-value-conc6-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc6 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc6-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc6-rep
  (b* ((csts (pdf-cst-dict-value-conc6-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc6-rep-match

(defthm pdf-cst-dict-value-conc6-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       6))
           (b* ((csts (pdf-cst-dict-value-conc6-rep cst)))
             (pdf-cst-list-rep-matchp csts "null")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc6-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc6-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc6-rep (tree-fix cst))
         (pdf-cst-dict-value-conc6-rep cst)))

Theorem: pdf-cst-dict-value-conc6-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc6-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc6-rep cst)
                  (pdf-cst-dict-value-conc6-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc7-rep

(defun pdf-cst-dict-value-conc7-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     7))))
  (let ((__function__ 'pdf-cst-dict-value-conc7-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc7 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc7-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc7-rep
  (b* ((csts (pdf-cst-dict-value-conc7-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc7-rep-match

(defthm pdf-cst-dict-value-conc7-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       7))
           (b* ((csts (pdf-cst-dict-value-conc7-rep cst)))
             (pdf-cst-list-rep-matchp csts "rectangle")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc7-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc7-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc7-rep (tree-fix cst))
         (pdf-cst-dict-value-conc7-rep cst)))

Theorem: pdf-cst-dict-value-conc7-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc7-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc7-rep cst)
                  (pdf-cst-dict-value-conc7-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc8-rep

(defun pdf-cst-dict-value-conc8-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     8))))
  (let ((__function__ 'pdf-cst-dict-value-conc8-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc8 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc8-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc8-rep
  (b* ((csts (pdf-cst-dict-value-conc8-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc8-rep-match

(defthm pdf-cst-dict-value-conc8-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       8))
           (b* ((csts (pdf-cst-dict-value-conc8-rep cst)))
             (pdf-cst-list-rep-matchp csts "reference")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc8-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc8-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc8-rep (tree-fix cst))
         (pdf-cst-dict-value-conc8-rep cst)))

Theorem: pdf-cst-dict-value-conc8-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc8-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc8-rep cst)
                  (pdf-cst-dict-value-conc8-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc9-rep

(defun pdf-cst-dict-value-conc9-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     9))))
  (let ((__function__ 'pdf-cst-dict-value-conc9-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-dict-value-conc9 cst)))))

Theorem: tree-listp-of-pdf-cst-dict-value-conc9-rep

(defthm tree-listp-of-pdf-cst-dict-value-conc9-rep
  (b* ((csts (pdf-cst-dict-value-conc9-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc9-rep-match

(defthm pdf-cst-dict-value-conc9-rep-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       9))
           (b* ((csts (pdf-cst-dict-value-conc9-rep cst)))
             (pdf-cst-list-rep-matchp csts "string")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc9-rep-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc9-rep-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc9-rep (tree-fix cst))
         (pdf-cst-dict-value-conc9-rep cst)))

Theorem: pdf-cst-dict-value-conc9-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-dict-value-conc9-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc9-rep cst)
                  (pdf-cst-dict-value-conc9-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-start-dict-conc-rep

(defun pdf-cst-start-dict-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "start-dict")))
  (let ((__function__ 'pdf-cst-start-dict-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-start-dict-conc cst)))))

Theorem: tree-listp-of-pdf-cst-start-dict-conc-rep

(defthm tree-listp-of-pdf-cst-start-dict-conc-rep
  (b* ((csts (pdf-cst-start-dict-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-start-dict-conc-rep-match

(defthm pdf-cst-start-dict-conc-rep-match
  (implies (pdf-cst-matchp cst "start-dict")
           (b* ((csts (pdf-cst-start-dict-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x3C.3C")))
  :rule-classes :rewrite)

Theorem: pdf-cst-start-dict-conc-rep-of-tree-fix-cst

(defthm pdf-cst-start-dict-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-start-dict-conc-rep (tree-fix cst))
         (pdf-cst-start-dict-conc-rep cst)))

Theorem: pdf-cst-start-dict-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-start-dict-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-start-dict-conc-rep cst)
                  (pdf-cst-start-dict-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-end-dict-conc-rep

(defun pdf-cst-end-dict-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "end-dict")))
  (let ((__function__ 'pdf-cst-end-dict-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-end-dict-conc cst)))))

Theorem: tree-listp-of-pdf-cst-end-dict-conc-rep

(defthm tree-listp-of-pdf-cst-end-dict-conc-rep
  (b* ((csts (pdf-cst-end-dict-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-end-dict-conc-rep-match

(defthm pdf-cst-end-dict-conc-rep-match
  (implies (pdf-cst-matchp cst "end-dict")
           (b* ((csts (pdf-cst-end-dict-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x3E.3E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-end-dict-conc-rep-of-tree-fix-cst

(defthm pdf-cst-end-dict-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-end-dict-conc-rep (tree-fix cst))
         (pdf-cst-end-dict-conc-rep cst)))

Theorem: pdf-cst-end-dict-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-end-dict-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-end-dict-conc-rep cst)
                  (pdf-cst-end-dict-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-digit1-9-conc-rep

(defun pdf-cst-digit1-9-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "digit1-9")))
  (let ((__function__ 'pdf-cst-digit1-9-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-digit1-9-conc cst)))))

Theorem: tree-listp-of-pdf-cst-digit1-9-conc-rep

(defthm tree-listp-of-pdf-cst-digit1-9-conc-rep
  (b* ((csts (pdf-cst-digit1-9-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit1-9-conc-rep-match

(defthm pdf-cst-digit1-9-conc-rep-match
  (implies (pdf-cst-matchp cst "digit1-9")
           (b* ((csts (pdf-cst-digit1-9-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x31-39")))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit1-9-conc-rep-of-tree-fix-cst

(defthm pdf-cst-digit1-9-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-digit1-9-conc-rep (tree-fix cst))
         (pdf-cst-digit1-9-conc-rep cst)))

Theorem: pdf-cst-digit1-9-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-digit1-9-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-digit1-9-conc-rep cst)
                  (pdf-cst-digit1-9-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-digit-conc-rep

(defun pdf-cst-digit-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "digit")))
  (let ((__function__ 'pdf-cst-digit-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-digit-conc cst)))))

Theorem: tree-listp-of-pdf-cst-digit-conc-rep

(defthm tree-listp-of-pdf-cst-digit-conc-rep
  (b* ((csts (pdf-cst-digit-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit-conc-rep-match

(defthm pdf-cst-digit-conc-rep-match
  (implies (pdf-cst-matchp cst "digit")
           (b* ((csts (pdf-cst-digit-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x30-39")))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit-conc-rep-of-tree-fix-cst

(defthm pdf-cst-digit-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-digit-conc-rep (tree-fix cst))
         (pdf-cst-digit-conc-rep cst)))

Theorem: pdf-cst-digit-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-digit-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-digit-conc-rep cst)
                  (pdf-cst-digit-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-left-bracket-conc-rep

(defun pdf-cst-left-bracket-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "left-bracket")))
  (let ((__function__ 'pdf-cst-left-bracket-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-left-bracket-conc cst)))))

Theorem: tree-listp-of-pdf-cst-left-bracket-conc-rep

(defthm tree-listp-of-pdf-cst-left-bracket-conc-rep
  (b* ((csts (pdf-cst-left-bracket-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-left-bracket-conc-rep-match

(defthm pdf-cst-left-bracket-conc-rep-match
  (implies (pdf-cst-matchp cst "left-bracket")
           (b* ((csts (pdf-cst-left-bracket-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x5B")))
  :rule-classes :rewrite)

Theorem: pdf-cst-left-bracket-conc-rep-of-tree-fix-cst

(defthm pdf-cst-left-bracket-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-left-bracket-conc-rep (tree-fix cst))
         (pdf-cst-left-bracket-conc-rep cst)))

Theorem: pdf-cst-left-bracket-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-left-bracket-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-left-bracket-conc-rep cst)
                  (pdf-cst-left-bracket-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-right-bracket-conc-rep

(defun pdf-cst-right-bracket-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "right-bracket")))
  (let ((__function__ 'pdf-cst-right-bracket-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-right-bracket-conc cst)))))

Theorem: tree-listp-of-pdf-cst-right-bracket-conc-rep

(defthm tree-listp-of-pdf-cst-right-bracket-conc-rep
  (b* ((csts (pdf-cst-right-bracket-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-right-bracket-conc-rep-match

(defthm pdf-cst-right-bracket-conc-rep-match
  (implies (pdf-cst-matchp cst "right-bracket")
           (b* ((csts (pdf-cst-right-bracket-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x5D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-right-bracket-conc-rep-of-tree-fix-cst

(defthm pdf-cst-right-bracket-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-right-bracket-conc-rep (tree-fix cst))
         (pdf-cst-right-bracket-conc-rep cst)))

Theorem: pdf-cst-right-bracket-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-right-bracket-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-right-bracket-conc-rep cst)
                  (pdf-cst-right-bracket-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-null-conc-rep

(defun pdf-cst-null-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "null")))
  (let ((__function__ 'pdf-cst-null-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-null-conc cst)))))

Theorem: tree-listp-of-pdf-cst-null-conc-rep

(defthm tree-listp-of-pdf-cst-null-conc-rep
  (b* ((csts (pdf-cst-null-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-null-conc-rep-match

(defthm pdf-cst-null-conc-rep-match
  (implies (pdf-cst-matchp cst "null")
           (b* ((csts (pdf-cst-null-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%s\"null\"")))
  :rule-classes :rewrite)

Theorem: pdf-cst-null-conc-rep-of-tree-fix-cst

(defthm pdf-cst-null-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-null-conc-rep (tree-fix cst))
         (pdf-cst-null-conc-rep cst)))

Theorem: pdf-cst-null-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-null-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-null-conc-rep cst)
                  (pdf-cst-null-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-name-char-conc-rep

(defun pdf-cst-name-char-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "name-char")))
  (let ((__function__ 'pdf-cst-name-char-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-name-char-conc cst)))))

Theorem: tree-listp-of-pdf-cst-name-char-conc-rep

(defthm tree-listp-of-pdf-cst-name-char-conc-rep
  (b* ((csts (pdf-cst-name-char-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-char-conc-rep-match

(defthm pdf-cst-name-char-conc-rep-match
  (implies (pdf-cst-matchp cst "name-char")
           (b* ((csts (pdf-cst-name-char-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x20-7E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-char-conc-rep-of-tree-fix-cst

(defthm pdf-cst-name-char-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-name-char-conc-rep (tree-fix cst))
         (pdf-cst-name-char-conc-rep cst)))

Theorem: pdf-cst-name-char-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-name-char-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-name-char-conc-rep cst)
                  (pdf-cst-name-char-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-plus-conc-rep

(defun pdf-cst-plus-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "plus")))
  (let ((__function__ 'pdf-cst-plus-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-plus-conc cst)))))

Theorem: tree-listp-of-pdf-cst-plus-conc-rep

(defthm tree-listp-of-pdf-cst-plus-conc-rep
  (b* ((csts (pdf-cst-plus-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-plus-conc-rep-match

(defthm pdf-cst-plus-conc-rep-match
  (implies (pdf-cst-matchp cst "plus")
           (b* ((csts (pdf-cst-plus-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x2B")))
  :rule-classes :rewrite)

Theorem: pdf-cst-plus-conc-rep-of-tree-fix-cst

(defthm pdf-cst-plus-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-plus-conc-rep (tree-fix cst))
         (pdf-cst-plus-conc-rep cst)))

Theorem: pdf-cst-plus-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-plus-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-plus-conc-rep cst)
                  (pdf-cst-plus-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-minus-conc-rep

(defun pdf-cst-minus-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "minus")))
  (let ((__function__ 'pdf-cst-minus-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-minus-conc cst)))))

Theorem: tree-listp-of-pdf-cst-minus-conc-rep

(defthm tree-listp-of-pdf-cst-minus-conc-rep
  (b* ((csts (pdf-cst-minus-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-minus-conc-rep-match

(defthm pdf-cst-minus-conc-rep-match
  (implies (pdf-cst-matchp cst "minus")
           (b* ((csts (pdf-cst-minus-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x2D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-minus-conc-rep-of-tree-fix-cst

(defthm pdf-cst-minus-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-minus-conc-rep (tree-fix cst))
         (pdf-cst-minus-conc-rep cst)))

Theorem: pdf-cst-minus-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-minus-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-minus-conc-rep cst)
                  (pdf-cst-minus-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-slash-conc-rep

(defun pdf-cst-slash-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "slash")))
  (let ((__function__ 'pdf-cst-slash-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-slash-conc cst)))))

Theorem: tree-listp-of-pdf-cst-slash-conc-rep

(defthm tree-listp-of-pdf-cst-slash-conc-rep
  (b* ((csts (pdf-cst-slash-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-slash-conc-rep-match

(defthm pdf-cst-slash-conc-rep-match
  (implies (pdf-cst-matchp cst "slash")
           (b* ((csts (pdf-cst-slash-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x2F")))
  :rule-classes :rewrite)

Theorem: pdf-cst-slash-conc-rep-of-tree-fix-cst

(defthm pdf-cst-slash-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-slash-conc-rep (tree-fix cst))
         (pdf-cst-slash-conc-rep cst)))

Theorem: pdf-cst-slash-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-slash-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-slash-conc-rep cst)
                  (pdf-cst-slash-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-backslash-conc-rep

(defun pdf-cst-backslash-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "backslash")))
  (let ((__function__ 'pdf-cst-backslash-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-backslash-conc cst)))))

Theorem: tree-listp-of-pdf-cst-backslash-conc-rep

(defthm tree-listp-of-pdf-cst-backslash-conc-rep
  (b* ((csts (pdf-cst-backslash-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-backslash-conc-rep-match

(defthm pdf-cst-backslash-conc-rep-match
  (implies (pdf-cst-matchp cst "backslash")
           (b* ((csts (pdf-cst-backslash-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x5C")))
  :rule-classes :rewrite)

Theorem: pdf-cst-backslash-conc-rep-of-tree-fix-cst

(defthm pdf-cst-backslash-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-backslash-conc-rep (tree-fix cst))
         (pdf-cst-backslash-conc-rep cst)))

Theorem: pdf-cst-backslash-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-backslash-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-backslash-conc-rep cst)
                  (pdf-cst-backslash-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-zero-conc-rep

(defun pdf-cst-zero-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "zero")))
  (let ((__function__ 'pdf-cst-zero-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-zero-conc cst)))))

Theorem: tree-listp-of-pdf-cst-zero-conc-rep

(defthm tree-listp-of-pdf-cst-zero-conc-rep
  (b* ((csts (pdf-cst-zero-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-zero-conc-rep-match

(defthm pdf-cst-zero-conc-rep-match
  (implies (pdf-cst-matchp cst "zero")
           (b* ((csts (pdf-cst-zero-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x30")))
  :rule-classes :rewrite)

Theorem: pdf-cst-zero-conc-rep-of-tree-fix-cst

(defthm pdf-cst-zero-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-zero-conc-rep (tree-fix cst))
         (pdf-cst-zero-conc-rep cst)))

Theorem: pdf-cst-zero-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-zero-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-zero-conc-rep cst)
                  (pdf-cst-zero-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-period-conc-rep

(defun pdf-cst-period-conc-rep (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "period")))
  (let ((__function__ 'pdf-cst-period-conc-rep))
    (declare (ignorable __function__))
    (tree-list-fix (nth 0 (pdf-cst-period-conc cst)))))

Theorem: tree-listp-of-pdf-cst-period-conc-rep

(defthm tree-listp-of-pdf-cst-period-conc-rep
  (b* ((csts (pdf-cst-period-conc-rep cst)))
    (tree-listp csts))
  :rule-classes :rewrite)

Theorem: pdf-cst-period-conc-rep-match

(defthm pdf-cst-period-conc-rep-match
  (implies (pdf-cst-matchp cst "period")
           (b* ((csts (pdf-cst-period-conc-rep cst)))
             (pdf-cst-list-rep-matchp csts "%x2E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-period-conc-rep-of-tree-fix-cst

(defthm pdf-cst-period-conc-rep-of-tree-fix-cst
  (equal (pdf-cst-period-conc-rep (tree-fix cst))
         (pdf-cst-period-conc-rep cst)))

Theorem: pdf-cst-period-conc-rep-tree-equiv-congruence-on-cst

(defthm pdf-cst-period-conc-rep-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-period-conc-rep cst)
                  (pdf-cst-period-conc-rep cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-pdf-marker-conc-rep-elem

(defun pdf-cst-pdf-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "pdf-marker")))
  (let ((__function__ 'pdf-cst-pdf-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-pdf-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-pdf-marker-conc-rep-elem

(defthm treep-of-pdf-cst-pdf-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-pdf-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-marker-conc-rep-elem-match

(defthm pdf-cst-pdf-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "pdf-marker")
           (b* ((cst1 (pdf-cst-pdf-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x25.50.44.46.45")))
  :rule-classes :rewrite)

Theorem: pdf-cst-pdf-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-pdf-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-pdf-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-pdf-marker-conc-rep-elem cst)))

Theorem: pdf-cst-pdf-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      pdf-cst-pdf-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-pdf-marker-conc-rep-elem cst)
                  (pdf-cst-pdf-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-obj-marker-conc-rep-elem

(defun pdf-cst-obj-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "obj-marker")))
  (let ((__function__ 'pdf-cst-obj-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-obj-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-obj-marker-conc-rep-elem

(defthm treep-of-pdf-cst-obj-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-obj-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-obj-marker-conc-rep-elem-match

(defthm pdf-cst-obj-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "obj-marker")
           (b* ((cst1 (pdf-cst-obj-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x6F.62.6A")))
  :rule-classes :rewrite)

Theorem: pdf-cst-obj-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-obj-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-obj-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-obj-marker-conc-rep-elem cst)))

Theorem: pdf-cst-obj-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      pdf-cst-obj-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-obj-marker-conc-rep-elem cst)
                  (pdf-cst-obj-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-endobj-marker-conc-rep-elem

(defun pdf-cst-endobj-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "endobj-marker")))
  (let ((__function__ 'pdf-cst-endobj-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-endobj-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-endobj-marker-conc-rep-elem

(defthm treep-of-pdf-cst-endobj-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-endobj-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-endobj-marker-conc-rep-elem-match

(defthm pdf-cst-endobj-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "endobj-marker")
           (b* ((cst1 (pdf-cst-endobj-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x65.6E.64.6F.62.6A")))
  :rule-classes :rewrite)

Theorem: pdf-cst-endobj-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-endobj-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-endobj-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-endobj-marker-conc-rep-elem cst)))

Theorem: pdf-cst-endobj-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   pdf-cst-endobj-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-endobj-marker-conc-rep-elem cst)
                  (pdf-cst-endobj-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-stream-marker-conc-rep-elem

(defun pdf-cst-stream-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "stream-marker")))
  (let ((__function__ 'pdf-cst-stream-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-stream-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-stream-marker-conc-rep-elem

(defthm treep-of-pdf-cst-stream-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-stream-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-marker-conc-rep-elem-match

(defthm pdf-cst-stream-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "stream-marker")
           (b* ((cst1 (pdf-cst-stream-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x73.74.72.65.61.6D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-stream-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-stream-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-stream-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-stream-marker-conc-rep-elem cst)))

Theorem: pdf-cst-stream-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   pdf-cst-stream-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-stream-marker-conc-rep-elem cst)
                  (pdf-cst-stream-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-endstream-marker-conc-rep-elem

(defun pdf-cst-endstream-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "endstream-marker")))
  (let ((__function__ 'pdf-cst-endstream-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-endstream-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-endstream-marker-conc-rep-elem

(defthm treep-of-pdf-cst-endstream-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-endstream-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-endstream-marker-conc-rep-elem-match

(defthm pdf-cst-endstream-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "endstream-marker")
           (b* ((cst1 (pdf-cst-endstream-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x65.6E.64.73.74.72.65.61.6D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-endstream-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-endstream-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-endstream-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-endstream-marker-conc-rep-elem cst)))

Theorem: pdf-cst-endstream-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 pdf-cst-endstream-marker-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (tree-equiv cst cst-equiv)
      (equal (pdf-cst-endstream-marker-conc-rep-elem cst)
             (pdf-cst-endstream-marker-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: pdf-cst-xref-marker-conc-rep-elem

(defun pdf-cst-xref-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "xref-marker")))
  (let ((__function__ 'pdf-cst-xref-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-xref-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-xref-marker-conc-rep-elem

(defthm treep-of-pdf-cst-xref-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-xref-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-marker-conc-rep-elem-match

(defthm pdf-cst-xref-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "xref-marker")
           (b* ((cst1 (pdf-cst-xref-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x78.72.65.66")))
  :rule-classes :rewrite)

Theorem: pdf-cst-xref-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-xref-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-xref-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-xref-marker-conc-rep-elem cst)))

Theorem: pdf-cst-xref-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-xref-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-xref-marker-conc-rep-elem cst)
                  (pdf-cst-xref-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-startxref-marker-conc-rep-elem

(defun pdf-cst-startxref-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "startxref-marker")))
  (let ((__function__ 'pdf-cst-startxref-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-startxref-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-startxref-marker-conc-rep-elem

(defthm treep-of-pdf-cst-startxref-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-startxref-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-startxref-marker-conc-rep-elem-match

(defthm pdf-cst-startxref-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "startxref-marker")
           (b* ((cst1 (pdf-cst-startxref-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x73.74.61.72.74.78.72.65.66")))
  :rule-classes :rewrite)

Theorem: pdf-cst-startxref-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-startxref-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-startxref-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-startxref-marker-conc-rep-elem cst)))

Theorem: pdf-cst-startxref-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
 pdf-cst-startxref-marker-conc-rep-elem-tree-equiv-congruence-on-cst
 (implies
      (tree-equiv cst cst-equiv)
      (equal (pdf-cst-startxref-marker-conc-rep-elem cst)
             (pdf-cst-startxref-marker-conc-rep-elem cst-equiv)))
 :rule-classes :congruence)

Function: pdf-cst-eof-marker-conc-rep-elem

(defun pdf-cst-eof-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "eof-marker")))
  (let ((__function__ 'pdf-cst-eof-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-eof-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-eof-marker-conc-rep-elem

(defthm treep-of-pdf-cst-eof-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-eof-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-eof-marker-conc-rep-elem-match

(defthm pdf-cst-eof-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "eof-marker")
           (b* ((cst1 (pdf-cst-eof-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x25.25.45.4F.46")))
  :rule-classes :rewrite)

Theorem: pdf-cst-eof-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-eof-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-eof-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-eof-marker-conc-rep-elem cst)))

Theorem: pdf-cst-eof-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      pdf-cst-eof-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-eof-marker-conc-rep-elem cst)
                  (pdf-cst-eof-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-trailer-marker-conc-rep-elem

(defun pdf-cst-trailer-marker-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "trailer-marker")))
  (let ((__function__ 'pdf-cst-trailer-marker-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-trailer-marker-conc-rep cst)))))

Theorem: treep-of-pdf-cst-trailer-marker-conc-rep-elem

(defthm treep-of-pdf-cst-trailer-marker-conc-rep-elem
  (b* ((cst1 (pdf-cst-trailer-marker-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-marker-conc-rep-elem-match

(defthm pdf-cst-trailer-marker-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "trailer-marker")
           (b* ((cst1 (pdf-cst-trailer-marker-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x74.72.61.69.6C.65.72")))
  :rule-classes :rewrite)

Theorem: pdf-cst-trailer-marker-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-trailer-marker-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-trailer-marker-conc-rep-elem (tree-fix cst))
         (pdf-cst-trailer-marker-conc-rep-elem cst)))

Theorem: pdf-cst-trailer-marker-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
  pdf-cst-trailer-marker-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-trailer-marker-conc-rep-elem cst)
                  (pdf-cst-trailer-marker-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc1-rep-elem

(defun pdf-cst-dict-entry-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     1))))
  (let ((__function__ 'pdf-cst-dict-entry-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc1-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc1-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc1-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc1-rep-elem-match

(defthm pdf-cst-dict-entry-conc1-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       1))
           (b* ((cst1 (pdf-cst-dict-entry-conc1-rep-elem cst)))
             (pdf-cst-matchp cst1 "type-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc1-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc1-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc1-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc1-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc1-rep-elem cst)
                  (pdf-cst-dict-entry-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc2-rep-elem

(defun pdf-cst-dict-entry-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     2))))
  (let ((__function__ 'pdf-cst-dict-entry-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc2-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc2-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc2-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc2-rep-elem-match

(defthm pdf-cst-dict-entry-conc2-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       2))
           (b* ((cst1 (pdf-cst-dict-entry-conc2-rep-elem cst)))
             (pdf-cst-matchp cst1 "reference-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc2-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc2-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc2-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc2-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc2-rep-elem cst)
                  (pdf-cst-dict-entry-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc3-rep-elem

(defun pdf-cst-dict-entry-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     3))))
  (let ((__function__ 'pdf-cst-dict-entry-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc3-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc3-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc3-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc3-rep-elem-match

(defthm pdf-cst-dict-entry-conc3-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       3))
           (b* ((cst1 (pdf-cst-dict-entry-conc3-rep-elem cst)))
             (pdf-cst-matchp cst1 "reference-array-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc3-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc3-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc3-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc3-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc3-rep-elem cst)
                  (pdf-cst-dict-entry-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc4-rep-elem

(defun pdf-cst-dict-entry-conc4-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     4))))
  (let ((__function__ 'pdf-cst-dict-entry-conc4-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc4-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc4-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc4-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc4-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc4-rep-elem-match

(defthm pdf-cst-dict-entry-conc4-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       4))
           (b* ((cst1 (pdf-cst-dict-entry-conc4-rep-elem cst)))
             (pdf-cst-matchp cst1 "rectangle-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc4-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc4-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc4-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc4-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc4-rep-elem cst)
                  (pdf-cst-dict-entry-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc5-rep-elem

(defun pdf-cst-dict-entry-conc5-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     5))))
  (let ((__function__ 'pdf-cst-dict-entry-conc5-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc5-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc5-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc5-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc5-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc5-rep-elem-match

(defthm pdf-cst-dict-entry-conc5-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       5))
           (b* ((cst1 (pdf-cst-dict-entry-conc5-rep-elem cst)))
             (pdf-cst-matchp cst1 "number-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc5-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc5-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc5-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc5-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc5-rep-elem cst)
                  (pdf-cst-dict-entry-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc6-rep-elem

(defun pdf-cst-dict-entry-conc6-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     6))))
  (let ((__function__ 'pdf-cst-dict-entry-conc6-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc6-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc6-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc6-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc6-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc6-rep-elem-match

(defthm pdf-cst-dict-entry-conc6-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       6))
           (b* ((cst1 (pdf-cst-dict-entry-conc6-rep-elem cst)))
             (pdf-cst-matchp cst1 "name-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc6-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc6-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc6-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc6-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc6-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc6-rep-elem cst)
                  (pdf-cst-dict-entry-conc6-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc7-rep-elem

(defun pdf-cst-dict-entry-conc7-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     7))))
  (let ((__function__ 'pdf-cst-dict-entry-conc7-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc7-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc7-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc7-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc7-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc7-rep-elem-match

(defthm pdf-cst-dict-entry-conc7-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       7))
           (b* ((cst1 (pdf-cst-dict-entry-conc7-rep-elem cst)))
             (pdf-cst-matchp cst1 "font-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc7-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc7-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc7-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc7-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc7-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc7-rep-elem cst)
                  (pdf-cst-dict-entry-conc7-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-entry-conc8-rep-elem

(defun pdf-cst-dict-entry-conc8-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-entry")
                              (equal (pdf-cst-dict-entry-conc? cst)
                                     8))))
  (let ((__function__ 'pdf-cst-dict-entry-conc8-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-entry-conc8-rep cst)))))

Theorem: treep-of-pdf-cst-dict-entry-conc8-rep-elem

(defthm treep-of-pdf-cst-dict-entry-conc8-rep-elem
  (b* ((cst1 (pdf-cst-dict-entry-conc8-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc8-rep-elem-match

(defthm pdf-cst-dict-entry-conc8-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-entry")
                (equal (pdf-cst-dict-entry-conc? cst)
                       8))
           (b* ((cst1 (pdf-cst-dict-entry-conc8-rep-elem cst)))
             (pdf-cst-matchp cst1 "default-entry")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-entry-conc8-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-entry-conc8-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-entry-conc8-rep-elem (tree-fix cst))
         (pdf-cst-dict-entry-conc8-rep-elem cst)))

Theorem: pdf-cst-dict-entry-conc8-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-entry-conc8-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-entry-conc8-rep-elem cst)
                  (pdf-cst-dict-entry-conc8-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc1-rep-elem

(defun pdf-cst-dict-value-conc1-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     1))))
  (let ((__function__ 'pdf-cst-dict-value-conc1-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc1-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc1-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc1-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc1-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc1-rep-elem-match

(defthm pdf-cst-dict-value-conc1-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       1))
           (b* ((cst1 (pdf-cst-dict-value-conc1-rep-elem cst)))
             (pdf-cst-matchp cst1 "boolean")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc1-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc1-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc1-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc1-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc1-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc1-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc1-rep-elem cst)
                  (pdf-cst-dict-value-conc1-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc2-rep-elem

(defun pdf-cst-dict-value-conc2-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     2))))
  (let ((__function__ 'pdf-cst-dict-value-conc2-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc2-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc2-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc2-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc2-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc2-rep-elem-match

(defthm pdf-cst-dict-value-conc2-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       2))
           (b* ((cst1 (pdf-cst-dict-value-conc2-rep-elem cst)))
             (pdf-cst-matchp cst1 "number")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc2-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc2-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc2-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc2-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc2-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc2-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc2-rep-elem cst)
                  (pdf-cst-dict-value-conc2-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc3-rep-elem

(defun pdf-cst-dict-value-conc3-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     3))))
  (let ((__function__ 'pdf-cst-dict-value-conc3-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc3-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc3-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc3-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc3-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc3-rep-elem-match

(defthm pdf-cst-dict-value-conc3-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       3))
           (b* ((cst1 (pdf-cst-dict-value-conc3-rep-elem cst)))
             (pdf-cst-matchp cst1 "name")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc3-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc3-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc3-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc3-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc3-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc3-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc3-rep-elem cst)
                  (pdf-cst-dict-value-conc3-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc4-rep-elem

(defun pdf-cst-dict-value-conc4-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     4))))
  (let ((__function__ 'pdf-cst-dict-value-conc4-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc4-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc4-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc4-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc4-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc4-rep-elem-match

(defthm pdf-cst-dict-value-conc4-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       4))
           (b* ((cst1 (pdf-cst-dict-value-conc4-rep-elem cst)))
             (pdf-cst-matchp cst1 "array")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc4-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc4-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc4-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc4-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc4-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc4-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc4-rep-elem cst)
                  (pdf-cst-dict-value-conc4-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc5-rep-elem

(defun pdf-cst-dict-value-conc5-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     5))))
  (let ((__function__ 'pdf-cst-dict-value-conc5-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc5-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc5-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc5-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc5-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc5-rep-elem-match

(defthm pdf-cst-dict-value-conc5-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       5))
           (b* ((cst1 (pdf-cst-dict-value-conc5-rep-elem cst)))
             (pdf-cst-matchp cst1 "dictionary")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc5-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc5-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc5-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc5-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc5-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc5-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc5-rep-elem cst)
                  (pdf-cst-dict-value-conc5-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc6-rep-elem

(defun pdf-cst-dict-value-conc6-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     6))))
  (let ((__function__ 'pdf-cst-dict-value-conc6-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc6-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc6-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc6-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc6-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc6-rep-elem-match

(defthm pdf-cst-dict-value-conc6-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       6))
           (b* ((cst1 (pdf-cst-dict-value-conc6-rep-elem cst)))
             (pdf-cst-matchp cst1 "null")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc6-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc6-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc6-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc6-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc6-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc6-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc6-rep-elem cst)
                  (pdf-cst-dict-value-conc6-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc7-rep-elem

(defun pdf-cst-dict-value-conc7-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     7))))
  (let ((__function__ 'pdf-cst-dict-value-conc7-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc7-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc7-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc7-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc7-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc7-rep-elem-match

(defthm pdf-cst-dict-value-conc7-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       7))
           (b* ((cst1 (pdf-cst-dict-value-conc7-rep-elem cst)))
             (pdf-cst-matchp cst1 "rectangle")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc7-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc7-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc7-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc7-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc7-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc7-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc7-rep-elem cst)
                  (pdf-cst-dict-value-conc7-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc8-rep-elem

(defun pdf-cst-dict-value-conc8-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     8))))
  (let ((__function__ 'pdf-cst-dict-value-conc8-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc8-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc8-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc8-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc8-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc8-rep-elem-match

(defthm pdf-cst-dict-value-conc8-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       8))
           (b* ((cst1 (pdf-cst-dict-value-conc8-rep-elem cst)))
             (pdf-cst-matchp cst1 "reference")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc8-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc8-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc8-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc8-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc8-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc8-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc8-rep-elem cst)
                  (pdf-cst-dict-value-conc8-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-dict-value-conc9-rep-elem

(defun pdf-cst-dict-value-conc9-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (and (pdf-cst-matchp cst "dict-value")
                              (equal (pdf-cst-dict-value-conc? cst)
                                     9))))
  (let ((__function__ 'pdf-cst-dict-value-conc9-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-dict-value-conc9-rep cst)))))

Theorem: treep-of-pdf-cst-dict-value-conc9-rep-elem

(defthm treep-of-pdf-cst-dict-value-conc9-rep-elem
  (b* ((cst1 (pdf-cst-dict-value-conc9-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc9-rep-elem-match

(defthm pdf-cst-dict-value-conc9-rep-elem-match
  (implies (and (pdf-cst-matchp cst "dict-value")
                (equal (pdf-cst-dict-value-conc? cst)
                       9))
           (b* ((cst1 (pdf-cst-dict-value-conc9-rep-elem cst)))
             (pdf-cst-matchp cst1 "string")))
  :rule-classes :rewrite)

Theorem: pdf-cst-dict-value-conc9-rep-elem-of-tree-fix-cst

(defthm pdf-cst-dict-value-conc9-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-dict-value-conc9-rep-elem (tree-fix cst))
         (pdf-cst-dict-value-conc9-rep-elem cst)))

Theorem: pdf-cst-dict-value-conc9-rep-elem-tree-equiv-congruence-on-cst

(defthm
     pdf-cst-dict-value-conc9-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-dict-value-conc9-rep-elem cst)
                  (pdf-cst-dict-value-conc9-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-start-dict-conc-rep-elem

(defun pdf-cst-start-dict-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "start-dict")))
  (let ((__function__ 'pdf-cst-start-dict-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-start-dict-conc-rep cst)))))

Theorem: treep-of-pdf-cst-start-dict-conc-rep-elem

(defthm treep-of-pdf-cst-start-dict-conc-rep-elem
  (b* ((cst1 (pdf-cst-start-dict-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-start-dict-conc-rep-elem-match

(defthm pdf-cst-start-dict-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "start-dict")
           (b* ((cst1 (pdf-cst-start-dict-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x3C.3C")))
  :rule-classes :rewrite)

Theorem: pdf-cst-start-dict-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-start-dict-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-start-dict-conc-rep-elem (tree-fix cst))
         (pdf-cst-start-dict-conc-rep-elem cst)))

Theorem: pdf-cst-start-dict-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
      pdf-cst-start-dict-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-start-dict-conc-rep-elem cst)
                  (pdf-cst-start-dict-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-end-dict-conc-rep-elem

(defun pdf-cst-end-dict-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "end-dict")))
  (let ((__function__ 'pdf-cst-end-dict-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-end-dict-conc-rep cst)))))

Theorem: treep-of-pdf-cst-end-dict-conc-rep-elem

(defthm treep-of-pdf-cst-end-dict-conc-rep-elem
  (b* ((cst1 (pdf-cst-end-dict-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-end-dict-conc-rep-elem-match

(defthm pdf-cst-end-dict-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "end-dict")
           (b* ((cst1 (pdf-cst-end-dict-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x3E.3E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-end-dict-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-end-dict-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-end-dict-conc-rep-elem (tree-fix cst))
         (pdf-cst-end-dict-conc-rep-elem cst)))

Theorem: pdf-cst-end-dict-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-end-dict-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-end-dict-conc-rep-elem cst)
                  (pdf-cst-end-dict-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-digit1-9-conc-rep-elem

(defun pdf-cst-digit1-9-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "digit1-9")))
  (let ((__function__ 'pdf-cst-digit1-9-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-digit1-9-conc-rep cst)))))

Theorem: treep-of-pdf-cst-digit1-9-conc-rep-elem

(defthm treep-of-pdf-cst-digit1-9-conc-rep-elem
  (b* ((cst1 (pdf-cst-digit1-9-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit1-9-conc-rep-elem-match

(defthm pdf-cst-digit1-9-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "digit1-9")
           (b* ((cst1 (pdf-cst-digit1-9-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x31-39")))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit1-9-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-digit1-9-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-digit1-9-conc-rep-elem (tree-fix cst))
         (pdf-cst-digit1-9-conc-rep-elem cst)))

Theorem: pdf-cst-digit1-9-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-digit1-9-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-digit1-9-conc-rep-elem cst)
                  (pdf-cst-digit1-9-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-digit-conc-rep-elem

(defun pdf-cst-digit-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "digit")))
  (let ((__function__ 'pdf-cst-digit-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-digit-conc-rep cst)))))

Theorem: treep-of-pdf-cst-digit-conc-rep-elem

(defthm treep-of-pdf-cst-digit-conc-rep-elem
  (b* ((cst1 (pdf-cst-digit-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit-conc-rep-elem-match

(defthm pdf-cst-digit-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "digit")
           (b* ((cst1 (pdf-cst-digit-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x30-39")))
  :rule-classes :rewrite)

Theorem: pdf-cst-digit-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-digit-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-digit-conc-rep-elem (tree-fix cst))
         (pdf-cst-digit-conc-rep-elem cst)))

Theorem: pdf-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-digit-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-digit-conc-rep-elem cst)
                  (pdf-cst-digit-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-left-bracket-conc-rep-elem

(defun pdf-cst-left-bracket-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "left-bracket")))
  (let ((__function__ 'pdf-cst-left-bracket-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-left-bracket-conc-rep cst)))))

Theorem: treep-of-pdf-cst-left-bracket-conc-rep-elem

(defthm treep-of-pdf-cst-left-bracket-conc-rep-elem
  (b* ((cst1 (pdf-cst-left-bracket-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-left-bracket-conc-rep-elem-match

(defthm pdf-cst-left-bracket-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "left-bracket")
           (b* ((cst1 (pdf-cst-left-bracket-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x5B")))
  :rule-classes :rewrite)

Theorem: pdf-cst-left-bracket-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-left-bracket-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-left-bracket-conc-rep-elem (tree-fix cst))
         (pdf-cst-left-bracket-conc-rep-elem cst)))

Theorem: pdf-cst-left-bracket-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
    pdf-cst-left-bracket-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-left-bracket-conc-rep-elem cst)
                  (pdf-cst-left-bracket-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-right-bracket-conc-rep-elem

(defun pdf-cst-right-bracket-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "right-bracket")))
  (let ((__function__ 'pdf-cst-right-bracket-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0
                   (pdf-cst-right-bracket-conc-rep cst)))))

Theorem: treep-of-pdf-cst-right-bracket-conc-rep-elem

(defthm treep-of-pdf-cst-right-bracket-conc-rep-elem
  (b* ((cst1 (pdf-cst-right-bracket-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-right-bracket-conc-rep-elem-match

(defthm pdf-cst-right-bracket-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "right-bracket")
           (b* ((cst1 (pdf-cst-right-bracket-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x5D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-right-bracket-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-right-bracket-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-right-bracket-conc-rep-elem (tree-fix cst))
         (pdf-cst-right-bracket-conc-rep-elem cst)))

Theorem: pdf-cst-right-bracket-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm
   pdf-cst-right-bracket-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-right-bracket-conc-rep-elem cst)
                  (pdf-cst-right-bracket-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-null-conc-rep-elem

(defun pdf-cst-null-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "null")))
  (let ((__function__ 'pdf-cst-null-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-null-conc-rep cst)))))

Theorem: treep-of-pdf-cst-null-conc-rep-elem

(defthm treep-of-pdf-cst-null-conc-rep-elem
  (b* ((cst1 (pdf-cst-null-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-null-conc-rep-elem-match

(defthm pdf-cst-null-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "null")
           (b* ((cst1 (pdf-cst-null-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%s\"null\"")))
  :rule-classes :rewrite)

Theorem: pdf-cst-null-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-null-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-null-conc-rep-elem (tree-fix cst))
         (pdf-cst-null-conc-rep-elem cst)))

Theorem: pdf-cst-null-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-null-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-null-conc-rep-elem cst)
                  (pdf-cst-null-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-name-char-conc-rep-elem

(defun pdf-cst-name-char-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "name-char")))
  (let ((__function__ 'pdf-cst-name-char-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-name-char-conc-rep cst)))))

Theorem: treep-of-pdf-cst-name-char-conc-rep-elem

(defthm treep-of-pdf-cst-name-char-conc-rep-elem
  (b* ((cst1 (pdf-cst-name-char-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-char-conc-rep-elem-match

(defthm pdf-cst-name-char-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "name-char")
           (b* ((cst1 (pdf-cst-name-char-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x20-7E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-name-char-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-name-char-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-name-char-conc-rep-elem (tree-fix cst))
         (pdf-cst-name-char-conc-rep-elem cst)))

Theorem: pdf-cst-name-char-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-name-char-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-name-char-conc-rep-elem cst)
                  (pdf-cst-name-char-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-plus-conc-rep-elem

(defun pdf-cst-plus-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "plus")))
  (let ((__function__ 'pdf-cst-plus-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-plus-conc-rep cst)))))

Theorem: treep-of-pdf-cst-plus-conc-rep-elem

(defthm treep-of-pdf-cst-plus-conc-rep-elem
  (b* ((cst1 (pdf-cst-plus-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-plus-conc-rep-elem-match

(defthm pdf-cst-plus-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "plus")
           (b* ((cst1 (pdf-cst-plus-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x2B")))
  :rule-classes :rewrite)

Theorem: pdf-cst-plus-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-plus-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-plus-conc-rep-elem (tree-fix cst))
         (pdf-cst-plus-conc-rep-elem cst)))

Theorem: pdf-cst-plus-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-plus-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-plus-conc-rep-elem cst)
                  (pdf-cst-plus-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-minus-conc-rep-elem

(defun pdf-cst-minus-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "minus")))
  (let ((__function__ 'pdf-cst-minus-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-minus-conc-rep cst)))))

Theorem: treep-of-pdf-cst-minus-conc-rep-elem

(defthm treep-of-pdf-cst-minus-conc-rep-elem
  (b* ((cst1 (pdf-cst-minus-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-minus-conc-rep-elem-match

(defthm pdf-cst-minus-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "minus")
           (b* ((cst1 (pdf-cst-minus-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x2D")))
  :rule-classes :rewrite)

Theorem: pdf-cst-minus-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-minus-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-minus-conc-rep-elem (tree-fix cst))
         (pdf-cst-minus-conc-rep-elem cst)))

Theorem: pdf-cst-minus-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-minus-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-minus-conc-rep-elem cst)
                  (pdf-cst-minus-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-slash-conc-rep-elem

(defun pdf-cst-slash-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "slash")))
  (let ((__function__ 'pdf-cst-slash-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-slash-conc-rep cst)))))

Theorem: treep-of-pdf-cst-slash-conc-rep-elem

(defthm treep-of-pdf-cst-slash-conc-rep-elem
  (b* ((cst1 (pdf-cst-slash-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-slash-conc-rep-elem-match

(defthm pdf-cst-slash-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "slash")
           (b* ((cst1 (pdf-cst-slash-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x2F")))
  :rule-classes :rewrite)

Theorem: pdf-cst-slash-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-slash-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-slash-conc-rep-elem (tree-fix cst))
         (pdf-cst-slash-conc-rep-elem cst)))

Theorem: pdf-cst-slash-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-slash-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-slash-conc-rep-elem cst)
                  (pdf-cst-slash-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-backslash-conc-rep-elem

(defun pdf-cst-backslash-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "backslash")))
  (let ((__function__ 'pdf-cst-backslash-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-backslash-conc-rep cst)))))

Theorem: treep-of-pdf-cst-backslash-conc-rep-elem

(defthm treep-of-pdf-cst-backslash-conc-rep-elem
  (b* ((cst1 (pdf-cst-backslash-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-backslash-conc-rep-elem-match

(defthm pdf-cst-backslash-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "backslash")
           (b* ((cst1 (pdf-cst-backslash-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x5C")))
  :rule-classes :rewrite)

Theorem: pdf-cst-backslash-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-backslash-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-backslash-conc-rep-elem (tree-fix cst))
         (pdf-cst-backslash-conc-rep-elem cst)))

Theorem: pdf-cst-backslash-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-backslash-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-backslash-conc-rep-elem cst)
                  (pdf-cst-backslash-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-zero-conc-rep-elem

(defun pdf-cst-zero-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "zero")))
  (let ((__function__ 'pdf-cst-zero-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-zero-conc-rep cst)))))

Theorem: treep-of-pdf-cst-zero-conc-rep-elem

(defthm treep-of-pdf-cst-zero-conc-rep-elem
  (b* ((cst1 (pdf-cst-zero-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-zero-conc-rep-elem-match

(defthm pdf-cst-zero-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "zero")
           (b* ((cst1 (pdf-cst-zero-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x30")))
  :rule-classes :rewrite)

Theorem: pdf-cst-zero-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-zero-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-zero-conc-rep-elem (tree-fix cst))
         (pdf-cst-zero-conc-rep-elem cst)))

Theorem: pdf-cst-zero-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-zero-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-zero-conc-rep-elem cst)
                  (pdf-cst-zero-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

Function: pdf-cst-period-conc-rep-elem

(defun pdf-cst-period-conc-rep-elem (cst)
  (declare (xargs :guard (treep cst)))
  (declare (xargs :guard (pdf-cst-matchp cst "period")))
  (let ((__function__ 'pdf-cst-period-conc-rep-elem))
    (declare (ignorable __function__))
    (tree-fix (nth 0 (pdf-cst-period-conc-rep cst)))))

Theorem: treep-of-pdf-cst-period-conc-rep-elem

(defthm treep-of-pdf-cst-period-conc-rep-elem
  (b* ((cst1 (pdf-cst-period-conc-rep-elem cst)))
    (treep cst1))
  :rule-classes :rewrite)

Theorem: pdf-cst-period-conc-rep-elem-match

(defthm pdf-cst-period-conc-rep-elem-match
  (implies (pdf-cst-matchp cst "period")
           (b* ((cst1 (pdf-cst-period-conc-rep-elem cst)))
             (pdf-cst-matchp cst1 "%x2E")))
  :rule-classes :rewrite)

Theorem: pdf-cst-period-conc-rep-elem-of-tree-fix-cst

(defthm pdf-cst-period-conc-rep-elem-of-tree-fix-cst
  (equal (pdf-cst-period-conc-rep-elem (tree-fix cst))
         (pdf-cst-period-conc-rep-elem cst)))

Theorem: pdf-cst-period-conc-rep-elem-tree-equiv-congruence-on-cst

(defthm pdf-cst-period-conc-rep-elem-tree-equiv-congruence-on-cst
  (implies (tree-equiv cst cst-equiv)
           (equal (pdf-cst-period-conc-rep-elem cst)
                  (pdf-cst-period-conc-rep-elem cst-equiv)))
  :rule-classes :congruence)

*pdf-grammar-rules*-tree-operations

Definitions and Theorems

pdf-grammar-rules-tree-operations