Move test_examplefiles to new tests/lexers scheme.examplefiles

1 files changed, 12550 insertions, 0 deletions

diff --git a/tests/lexers/common-lisp/example.txt b/tests/lexers/common-lisp/example.txt
new file mode 100644
index 00000000..ef52b5ce
--- /dev/null
+++ b/tests/lexers/common-lisp/example.txt
@@ -0,0 +1,12550 @@
+---input---
+;;;; TYPEP und Verwandtes
+;;;; Michael Stoll, 21. 10. 1988
+;;;; Bruno Haible, 10.6.1989
+;;;; Sam Steingold 2000-2005
+
+;;; Datenstrukturen für TYPEP:
+;;; - Ein Type-Specifier-Symbol hat auf seiner Propertyliste unter dem
+;;;   Indikator SYS::TYPE-SYMBOL eine Funktion von einem Argument, die
+;;;   testet, ob ein Objekt vom richtigen Typ ist.
+;;; - Ein Symbol, das eine Type-Specifier-Liste beginnen kann, hat auf seiner
+;;;   Propertyliste unter dem Indikator SYS::TYPE-LIST eine Funktion von
+;;;   einem Argument für das zu testende Objekt und zusätzlichen Argumenten
+;;;   für die Listenelemente.
+;;; - Ein Symbol, das als Typmacro definiert wurde, hat auf seiner Property-
+;;;   liste unter dem Indikator SYSTEM::DEFTYPE-EXPANDER den zugehörigen
+;;;   Expander: eine Funktion, die den zu expandierenden Type-Specifier (eine
+;;;   mindestens einelementige Liste) als Argument bekommt.
+
+(in-package "EXT")
+(export '(type-expand))
+(in-package "SYSTEM")
+
+; vorläufig, solange bis clos.lisp geladen wird:
+(eval-when (eval)
+  (predefun clos::built-in-class-p (object) (declare (ignore object)) nil))
+(unless (fboundp 'clos::class-name)
+  (defun clos::class-name (c) (declare (ignore c)) nil)
+)
+
+(defun typespec-error (fun type)
+  (error-of-type 'error
+    (TEXT "~S: invalid type specification ~S")
+    fun type
+) )
+
+;; ============================================================================
+
+;; return the CLOS class named by TYPESPEC or NIL
+(defun clos-class (typespec)
+  (let ((cc (get typespec 'CLOS::CLOSCLASS)))
+    (when (and cc (clos::defined-class-p cc) (eq (clos:class-name cc) typespec))
+      cc)))
+
+;;; TYPEP, CLTL S. 72, S. 42-51
+(defun typep (x y &optional env &aux f) ; x = Objekt, y = Typ
+  (declare (ignore env))
+  (setq y (expand-deftype y))
+  (cond
+    ((symbolp y)
+       (cond ((setq f (get y 'TYPE-SYMBOL)) (funcall f x))
+             ((setq f (get y 'TYPE-LIST)) (funcall f x))
+             ((setq f (get y 'DEFSTRUCT-DESCRIPTION)) (ds-typep x y f))
+             ((setq f (clos-class y))
+              ; It's not worth handling structure classes specially here.
+              (clos::typep-class x f))
+             (t (typespec-error 'typep y))
+    )  )
+    ((and (consp y) (symbolp (first y)))
+       (cond
+         ((and (eq (first y) 'SATISFIES) (eql (length y) 2))
+            (unless (symbolp (second y))
+              (error-of-type 'error
+                (TEXT "~S: argument to SATISFIES must be a symbol: ~S")
+                'typep (second y)
+            ) )
+            (if (funcall (symbol-function (second y)) x) t nil)
+         )
+         ((eq (first y) 'MEMBER)
+            (if (member x (rest y)) t nil)
+         )
+         ((and (eq (first y) 'EQL) (eql (length y) 2))
+            (eql x (second y))
+         )
+         ((and (eq (first y) 'NOT) (eql (length y) 2))
+            (not (typep x (second y)))
+         )
+         ((eq (first y) 'AND)
+            (dolist (type (rest y) t)
+              (unless (typep x type) (return nil))
+         )  )
+         ((eq (first y) 'OR)
+            (dolist (type (rest y) nil)
+              (when (typep x type) (return t))
+         )  )
+         ((setq f (get (first y) 'TYPE-LIST)) (apply f x (rest y)))
+         (t (typespec-error 'typep y))
+    )  )
+    ((clos::defined-class-p y) (clos::typep-class x y))
+    ((clos::eql-specializer-p y) (eql x (clos::eql-specializer-singleton y)))
+    ((encodingp y) (charset-typep x y))
+    (t (typespec-error 'typep y))
+) )
+
+;; ----------------------------------------------------------------------------
+
+;; UPGRADED-ARRAY-ELEMENT-TYPE is a lattice homomorphism, see
+;; ANSI CL 15.1.2.1.
+(defun upgraded-array-element-type (type &optional environment)
+  (declare (ignore environment))
+  ;; see array.d
+  (case type
+    ((BIT) 'BIT)
+    ((CHARACTER) 'CHARACTER)
+    ((T) 'T)
+    ((NIL) 'NIL)
+    (t (if (subtypep type 'NIL)
+         'NIL
+         (multiple-value-bind (low high) (sys::subtype-integer type)
+           ; Es gilt (or (null low) (subtypep type `(INTEGER ,low ,high)))
+           (if (and (integerp low) (not (minusp low)) (integerp high))
+             (let ((l (integer-length high)))
+               ; Es gilt (subtypep type `(UNSIGNED-BYTE ,l))
+               (cond ((<= l 1) 'BIT)
+                     ((<= l 2) '(UNSIGNED-BYTE 2))
+                     ((<= l 4) '(UNSIGNED-BYTE 4))
+                     ((<= l 8) '(UNSIGNED-BYTE 8))
+                     ((<= l 16) '(UNSIGNED-BYTE 16))
+                     ((<= l 32) '(UNSIGNED-BYTE 32))
+                     (t 'T)))
+             (if (subtypep type 'CHARACTER)
+               'CHARACTER
+               'T)))))))
+
+;; ----------------------------------------------------------------------------
+
+;; UPGRADED-COMPLEX-PART-TYPE is a lattice homomorphism, see
+;; HyperSpec/Body/fun_complex.html and HyperSpec/Body/syscla_complex.html,
+;; and an idempotent. Therefore
+;;   (subtypep (upgraded-complex-part-type T1) (upgraded-complex-part-type T2))
+;; is equivalent to
+;;   (subtypep T1 (upgraded-complex-part-type T2))
+;; (Proof: Let U T be an abbreviation for (upgraded-complex-part-type T).
+;;  If U T1 <= U T2, then T1 <= U T1 <= U T2.
+;;  If T1 <= U T2, then by homomorphism U T1 <= U U T2 = U T2.)
+;;
+;; For _any_ CL implementation, you could define
+;;   (defun upgraded-complex-part-type (type) 'REAL)
+;; Likewise for _any_ CL implementation, you could define
+;;   (defun upgraded-complex-part-type (type) type)
+;; or - again for _any_ CL implementation:
+;;   (defun upgraded-complex-part-type (type)
+;;     (cond ((subtypep type 'NIL) 'NIL)
+;;           ((subtypep type 'SHORT-FLOAT) 'SHORT-FLOAT)
+;;           ((subtypep type 'SINGLE-FLOAT) 'SINGLE-FLOAT)
+;;           ((subtypep type 'DOUBLE-FLOAT) 'DOUBLE-FLOAT)
+;;           ((subtypep type 'LONG-FLOAT) 'LONG-FLOAT)
+;;           ((subtypep type 'RATIONAL) 'RATIONAL)
+;;           ((subtypep type 'REAL) 'REAL)
+;;           (t (error ...))))
+;; The reason is that a complex number is immutable: no setters for the
+;; realpart and imagpart exist.
+;;
+;; We choose the second implementation because it allows the most precise
+;; type inference.
+(defun upgraded-complex-part-type (type &optional environment)
+  (declare (ignore environment))
+  (if (subtypep type 'REAL)
+    type
+    (error-of-type 'error
+      (TEXT "~S: type ~S is not a subtype of ~S")
+      'upgraded-complex-part-type type 'real)))
+
+;; ----------------------------------------------------------------------------
+
+;; Macros for defining the various built-in "atomic type specifier"s and
+;; "compound type specifier"s. The following macros add information for both
+;; the TYPEP function above and the c-TYPEP in the compiler.
+
+; Alist symbol -> funname, used by the compiler.
+(defparameter c-typep-alist1 '())
+; Alist symbol -> lambdabody, used by the compiler.
+(defparameter c-typep-alist2 '())
+; Alist symbol -> expander function, used by the compiler.
+(defparameter c-typep-alist3 '())
+
+; (def-atomic-type symbol function-name)
+; defines an atomic type. The function-name designates a function taking one
+; argument and returning a generalized boolean value. It can be either a
+; symbol or a lambda expression.
+(defmacro def-atomic-type (symbol funname)
+  (let ((lambdap (and (consp funname) (eq (car funname) 'LAMBDA))))
+    `(PROGN
+       (SETF (GET ',symbol 'TYPE-SYMBOL)
+             ,(if lambdap
+                `(FUNCTION ,(concat-pnames "TYPE-SYMBOL-" symbol) ,funname)
+                `(FUNCTION ,funname)
+              )
+       )
+       ,(if lambdap
+          `(SETQ C-TYPEP-ALIST2
+                 (NCONC C-TYPEP-ALIST2 (LIST (CONS ',symbol ',(cdr funname))))
+           )
+          `(SETQ C-TYPEP-ALIST1
+                 (NCONC C-TYPEP-ALIST1 (LIST (CONS ',symbol ',funname)))
+           )
+        )
+       ',symbol
+     )
+) )
+
+; (def-compound-type symbol lambda-list (x) check-form typep-form c-typep-form)
+; defines a compound type. The lambda-list is of the form (&optional ...)
+; where the arguments come from the CDR of the type specifier.
+; For typep-form, x is an object.
+; For c-typep-form, x is a multiply evaluatable form (actually a gensym).
+; check-form is a form performing error checking, may call `error'.
+; typep-form should return a generalized boolean value.
+; c-typep-form should produce a form returning a generalized boolean value.
+(defmacro def-compound-type (symbol lambdalist (var) check-form typep-form c-typep-form)
+  `(PROGN
+     (SETF (GET ',symbol 'TYPE-LIST)
+           (FUNCTION ,(concat-pnames "TYPE-LIST-" symbol)
+             (LAMBDA (,var ,@lambdalist)
+               ,@(if check-form
+                   `((MACROLET ((ERROR (&REST ERROR-ARGS)
+                                  (LIST* 'ERROR-OF-TYPE ''ERROR ERROR-ARGS)
+                               ))
+                       ,check-form
+                    ))
+                 )
+               ,typep-form
+     )     ) )
+     (SETQ C-TYPEP-ALIST3
+           (NCONC C-TYPEP-ALIST3
+                  (LIST (CONS ',symbol
+                              #'(LAMBDA (,var ,@lambdalist &REST ILLEGAL-ARGS)
+                                  (DECLARE (IGNORE ILLEGAL-ARGS))
+                                  ,@(if check-form
+                                      `((MACROLET ((ERROR (&REST ERROR-ARGS)
+                                                     (LIST 'PROGN
+                                                           (LIST* 'C-WARN ERROR-ARGS)
+                                                           '(THROW 'C-TYPEP NIL)
+                                                  )) )
+                                          ,check-form
+                                       ))
+                                    )
+                                  ,c-typep-form
+                                )
+     )     )      )     )
+     ',symbol
+   )
+)
+
+; CLtL1 p. 43
+(def-atomic-type ARRAY arrayp)
+(def-atomic-type ATOM atom)
+(def-atomic-type BASE-CHAR
+  #+BASE-CHAR=CHARACTER
+  characterp
+  #-BASE-CHAR=CHARACTER
+  (lambda (x) (and (characterp x) (base-char-p x)))
+)
+(def-atomic-type BASE-STRING
+  (lambda (x)
+    (and (stringp x)
+         (eq (array-element-type x)
+             #+BASE-CHAR=CHARACTER 'CHARACTER #-BASE-CHAR=CHARACTER 'BASE-CHAR
+) ) )    )
+(def-atomic-type BIGNUM
+  (lambda (x) (and (integerp x) (not (fixnump x))))
+)
+(def-atomic-type BIT
+  (lambda (x) (or (eql x 0) (eql x 1)))
+)
+(def-atomic-type BIT-VECTOR bit-vector-p)
+(def-atomic-type BOOLEAN
+  (lambda (x) (or (eq x 'nil) (eq x 't)))
+)
+(def-atomic-type CHARACTER characterp)
+(def-atomic-type COMPILED-FUNCTION compiled-function-p)
+(def-atomic-type COMPLEX complexp)
+(def-atomic-type CONS consp)
+(def-atomic-type DOUBLE-FLOAT double-float-p)
+(def-atomic-type ENCODING encodingp)
+(def-atomic-type EXTENDED-CHAR
+  #+BASE-CHAR=CHARACTER
+  (lambda (x) (declare (ignore x)) nil)
+  #-BASE-CHAR=CHARACTER
+  (lambda (x) (and (characterp x) (not (base-char-p x))))
+)
+(def-atomic-type FIXNUM fixnump)
+(def-atomic-type FLOAT floatp)
+(def-atomic-type FUNCTION functionp)
+(def-atomic-type HASH-TABLE hash-table-p)
+(def-atomic-type INTEGER integerp)
+(def-atomic-type KEYWORD keywordp)
+(def-atomic-type LIST listp)
+#+LOGICAL-PATHNAMES
+(def-atomic-type LOGICAL-PATHNAME logical-pathname-p)
+(def-atomic-type LONG-FLOAT long-float-p)
+(def-atomic-type NIL
+  (lambda (x) (declare (ignore x)) nil)
+)
+(def-atomic-type NULL null)
+(def-atomic-type NUMBER numberp)
+(def-atomic-type PACKAGE packagep)
+(def-atomic-type PATHNAME pathnamep)
+(def-atomic-type RANDOM-STATE random-state-p)
+(def-atomic-type RATIO
+  (lambda (x) (and (rationalp x) (not (integerp x))))
+)
+(def-atomic-type RATIONAL rationalp)
+(def-atomic-type READTABLE readtablep)
+(def-atomic-type REAL realp)
+(def-atomic-type SEQUENCE sequencep)
+(def-atomic-type SHORT-FLOAT short-float-p)
+(def-atomic-type SIMPLE-ARRAY simple-array-p)
+(def-atomic-type SIMPLE-BASE-STRING
+  (lambda (x)
+    (and (simple-string-p x)
+         (eq (array-element-type x)
+             #+BASE-CHAR=CHARACTER 'CHARACTER #-BASE-CHAR=CHARACTER 'BASE-CHAR
+) ) )    )
+(def-atomic-type SIMPLE-BIT-VECTOR simple-bit-vector-p)
+(def-atomic-type SIMPLE-STRING simple-string-p)
+(def-atomic-type SIMPLE-VECTOR simple-vector-p)
+(def-atomic-type SINGLE-FLOAT single-float-p)
+(defun %standard-char-p (x) (and (characterp x) (standard-char-p x))) ; ABI
+(def-atomic-type STANDARD-CHAR %standard-char-p)
+(def-atomic-type CLOS:STANDARD-OBJECT clos::std-instance-p)
+(def-atomic-type STREAM streamp)
+(def-atomic-type FILE-STREAM file-stream-p)
+(def-atomic-type SYNONYM-STREAM synonym-stream-p)
+(def-atomic-type BROADCAST-STREAM broadcast-stream-p)
+(def-atomic-type CONCATENATED-STREAM concatenated-stream-p)
+(def-atomic-type TWO-WAY-STREAM two-way-stream-p)
+(def-atomic-type ECHO-STREAM echo-stream-p)
+(def-atomic-type STRING-STREAM string-stream-p)
+(def-atomic-type STRING stringp)
+(def-atomic-type STRING-CHAR characterp)
+(def-atomic-type CLOS:STRUCTURE-OBJECT clos::structure-object-p)
+(def-atomic-type SYMBOL symbolp)
+(def-atomic-type T (lambda (x) (declare (ignore x)) t))
+;; foreign1.lisp is loaded after this file,
+;; so these symbols are not external yet
+#+ffi
+(def-atomic-type ffi::foreign-function
+  (lambda (x) (eq 'ffi::foreign-function (type-of x))))
+#+ffi
+(def-atomic-type ffi::foreign-variable
+  (lambda (x) (eq 'ffi::foreign-variable (type-of x))))
+#+ffi
+(def-atomic-type ffi::foreign-address
+  (lambda (x) (eq 'ffi::foreign-address (type-of x))))
+;; see lispbibl.d (#define FOREIGN) and predtype.d (TYPE-OF):
+#+(or unix ffi affi win32)
+(def-atomic-type foreign-pointer
+  (lambda (x) (eq 'foreign-pointer (type-of x))))
+(def-atomic-type VECTOR vectorp)
+(def-atomic-type PLIST
+    (lambda (x) (multiple-value-bind (length tail) (list-length-dotted x)
+                  (and (null tail) (evenp length)))))
+
+(defmacro ensure-dim (type dim)
+  ;; make sure DIM is a valid dimension
+  `(unless (or (eq ,dim '*) (typep ,dim `(INTEGER 0 (,ARRAY-DIMENSION-LIMIT))))
+     (error (TEXT "~S: dimension ~S is invalid") ',type ,dim)))
+
+(defmacro ensure-rank (type rank)
+  ;; make sure RANK is a valid rank
+  `(unless (typep ,rank `(INTEGER 0 (,ARRAY-RANK-LIMIT)))
+     (error (TEXT "~S: rank ~S is invalid") ',type ,rank)))
+
+; CLtL1 p. 46-50
+(defun c-typep-array (tester el-type dims x)
+  `(AND (,tester ,x)
+        ,@(if (eq el-type '*)
+            '()
+            `((EQUAL (ARRAY-ELEMENT-TYPE ,x) ',(upgraded-array-element-type el-type)))
+          )
+        ,@(if (eq dims '*)
+            '()
+            (if (numberp dims)
+              `((EQL ,dims (ARRAY-RANK ,x)))
+              `((EQL ,(length dims) (ARRAY-RANK ,x))
+                ,@(let ((i 0))
+                    (mapcap #'(lambda (dim)
+                                (prog1
+                                  (if (eq dim '*)
+                                    '()
+                                    `((EQL ',dim (ARRAY-DIMENSION ,x ,i)))
+                                  )
+                                  (incf i)
+                              ) )
+                            dims
+                  ) )
+               )
+          ) )
+   )
+)
+(defun c-typep-vector (tester size x)
+  `(AND (,tester ,x)
+        ,@(if (eq size '*)
+            '()
+            `((EQL ',size (ARRAY-DIMENSION ,x 0)))
+          )
+   )
+)
+(defun typep-number-test (x low high test type)
+  (and (funcall test x)
+       (cond ((eq low '*))
+             ((funcall test low) (<= low x))
+             ((and (consp low) (null (rest low)) (funcall test (first low)))
+                (< (first low) x)
+             )
+             (t (error-of-type 'error
+                  #1=(TEXT "~S: argument to ~S must be *, ~S or a list of ~S: ~S")
+                  'typep type type type low
+       )     )  )
+       (cond ((eq high '*))
+             ((funcall test high) (>= high x))
+             ((and (consp high) (null (rest high)) (funcall test (first high)))
+                (> (first high) x)
+             )
+             (t (error-of-type 'error
+                  #1# 'typep type type type high
+) )    )     )  )
+(defun c-typep-number (caller tester low high x)
+  `(AND (,tester ,x)
+        ,@(cond ((eq low '*) '())
+                ((funcall tester low) `((<= ,low ,x)))
+                ((and (consp low) (null (rest low)) (funcall tester (first low)))
+                 `((< ,(first low) ,x))
+                )
+                (t (c-warn #1=(TEXT "~S: argument to ~S must be *, ~S or a list of ~S: ~S")
+                           'typep caller caller caller low
+                   )
+                   (throw 'c-TYPEP nil)
+          )     )
+        ,@(cond ((eq high '*) '())
+                ((funcall tester high) `((>= ,high ,x)))
+                ((and (consp high) (null (rest high)) (funcall tester (first high)))
+                 `((> ,(first high) ,x))
+                )
+                (t (c-warn #1# 'typep caller caller caller high)
+                   (throw 'c-TYPEP nil)
+          )     )
+   )
+)
+(def-compound-type ARRAY (&optional (el-type '*) (dims '*)) (x)
+  (unless (eq dims '*)
+    (if (numberp dims)
+      (ensure-rank ARRAY dims)
+      (dolist (dim dims) (ensure-dim ARRAY dim))))
+  (and (arrayp x)
+       (or (eq el-type '*)
+           (equal (array-element-type x) (upgraded-array-element-type el-type))
+       )
+       (or (eq dims '*)
+           (if (numberp dims)
+             (eql dims (array-rank x))
+             (and (eql (length dims) (array-rank x))
+                  (every #'(lambda (a b) (or (eq a '*) (eql a b)))
+                         dims (array-dimensions x)
+  )    )   ) )    )
+  (c-typep-array 'ARRAYP el-type dims x)
+)
+(def-compound-type SIMPLE-ARRAY (&optional (el-type '*) (dims '*)) (x)
+  (unless (eq dims '*)
+    (if (numberp dims)
+      (ensure-rank SIMPLE-ARRAY dims)
+      (dolist (dim dims) (ensure-dim SIMPLE-ARRAY dim))))
+  (and (simple-array-p x)
+       (or (eq el-type '*)
+           (equal (array-element-type x) (upgraded-array-element-type el-type))
+       )
+       (or (eq dims '*)
+           (if (numberp dims)
+             (eql dims (array-rank x))
+             (and (eql (length dims) (array-rank x))
+                  (every #'(lambda (a b) (or (eq a '*) (eql a b)))
+                         dims (array-dimensions x)
+  )    )   ) )    )
+  (c-typep-array 'SIMPLE-ARRAY-P el-type dims x)
+)
+(def-compound-type VECTOR (&optional (el-type '*) (size '*)) (x)
+  (ensure-dim VECTOR size)
+  (and (vectorp x)
+       (or (eq el-type '*)
+           (equal (array-element-type x) (upgraded-array-element-type el-type))
+       )
+       (or (eq size '*) (eql (array-dimension x 0) size))
+  )
+  `(AND (VECTORP ,x)
+        ,@(if (eq el-type '*)
+            '()
+            `((EQUAL (ARRAY-ELEMENT-TYPE ,x) ',(upgraded-array-element-type el-type)))
+          )
+        ,@(if (eq size '*)
+            '()
+            `((EQL (ARRAY-DIMENSION ,x 0) ',size))
+          )
+   )
+)
+(def-compound-type SIMPLE-VECTOR (&optional (size '*)) (x)
+  (ensure-dim SIMLPE-VECTOR size)
+  (and (simple-vector-p x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'SIMPLE-VECTOR-P size x)
+)
+(def-compound-type COMPLEX (&optional (rtype '*) (itype rtype)) (x)
+  nil
+  (and (complexp x)
+       (or (eq rtype '*)
+           (typep (realpart x) (upgraded-complex-part-type rtype)))
+       (or (eq itype '*)
+           (typep (imagpart x) (upgraded-complex-part-type itype))))
+  `(AND (COMPLEXP ,x)
+        ,@(if (eq rtype '*)
+            '()
+            `((TYPEP (REALPART ,x) ',(upgraded-complex-part-type rtype))))
+        ,@(if (eq itype '*)
+            '()
+            `((TYPEP (IMAGPART ,x) ',(upgraded-complex-part-type itype))))))
+(def-compound-type INTEGER (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'integerp 'INTEGER)
+  (c-typep-number 'INTEGER 'INTEGERP low high x)
+)
+(def-compound-type MOD (n) (x)
+  (unless (integerp n)
+    (error (TEXT "~S: argument to MOD must be an integer: ~S")
+           'typep n
+  ) )
+  (and (integerp x) (<= 0 x) (< x n))
+  `(AND (INTEGERP ,x) (NOT (MINUSP ,x)) (< ,x ,n))
+)
+(def-compound-type SIGNED-BYTE (&optional (n '*)) (x)
+  (unless (or (eq n '*) (integerp n))
+    (error (TEXT "~S: argument to SIGNED-BYTE must be an integer or * : ~S")
+           'typep n
+  ) )
+  (and (integerp x) (or (eq n '*) (< (integer-length x) n)))
+  `(AND (INTEGERP ,x)
+        ,@(if (eq n '*) '() `((< (INTEGER-LENGTH ,x) ,n)))
+   )
+)
+(def-compound-type UNSIGNED-BYTE (&optional (n '*)) (x)
+  (unless (or (eq n '*) (integerp n))
+    (error (TEXT "~S: argument to UNSIGNED-BYTE must be an integer or * : ~S")
+           'typep n
+  ) )
+  (and (integerp x)
+       (not (minusp x))
+       (or (eq n '*) (<= (integer-length x) n))
+  )
+  `(AND (INTEGERP ,x) (NOT (MINUSP ,x))
+        ,@(if (eq n '*) '() `((<= (INTEGER-LENGTH ,x) ,n)))
+   )
+)
+(def-compound-type REAL (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'realp 'REAL)
+  (c-typep-number 'REAL 'REALP low high x)
+)
+(def-compound-type RATIONAL (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'rationalp 'RATIONAL)
+  (c-typep-number 'RATIONAL 'RATIONALP low high x)
+)
+(def-compound-type FLOAT (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'floatp 'FLOAT)
+  (c-typep-number 'FLOAT 'FLOATP low high x)
+)
+(def-compound-type SHORT-FLOAT (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'short-float-p 'SHORT-FLOAT)
+  (c-typep-number 'SHORT-FLOAT 'SHORT-FLOAT-P low high x)
+)
+(def-compound-type SINGLE-FLOAT (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'single-float-p 'SINGLE-FLOAT)
+  (c-typep-number 'SINGLE-FLOAT 'SINGLE-FLOAT-P low high x)
+)
+(def-compound-type DOUBLE-FLOAT (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'double-float-p 'DOUBLE-FLOAT)
+  (c-typep-number 'DOUBLE-FLOAT 'DOUBLE-FLOAT-P low high x)
+)
+(def-compound-type LONG-FLOAT (&optional (low '*) (high '*)) (x)
+  nil
+  (typep-number-test x low high #'long-float-p 'LONG-FLOAT)
+  (c-typep-number 'LONG-FLOAT 'LONG-FLOAT-P low high x)
+)
+(def-compound-type STRING (&optional (size '*)) (x)
+  (ensure-dim STRING size)
+  (and (stringp x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'STRINGP size x)
+)
+(def-compound-type SIMPLE-STRING (&optional (size '*)) (x)
+  (ensure-dim SIMPLE-STRING size)
+  (and (simple-string-p x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'SIMPLE-STRING-P size x)
+)
+(def-compound-type BASE-STRING (&optional (size '*)) (x)
+  (ensure-dim BASE-STRING size)
+  (and (stringp x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'STRINGP size x)
+)
+(def-compound-type SIMPLE-BASE-STRING (&optional (size '*)) (x)
+  (ensure-dim SIMPLE-BASE-STRING size)
+  (and (simple-string-p x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'SIMPLE-STRING-P size x)
+)
+(def-compound-type BIT-VECTOR (&optional (size '*)) (x)
+  (ensure-dim BIT-VECTOR size)
+  (and (bit-vector-p x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'BIT-VECTOR-P size x)
+)
+(def-compound-type SIMPLE-BIT-VECTOR (&optional (size '*)) (x)
+  (ensure-dim SIMPLE-BIT-VECTOR size)
+  (and (simple-bit-vector-p x)
+       (or (eq size '*) (eql size (array-dimension x 0)))
+  )
+  (c-typep-vector 'SIMPLE-BIT-VECTOR-P size x)
+)
+(def-compound-type CONS (&optional (car-type '*) (cdr-type '*)) (x)
+  nil
+  (and (consp x)
+       (or (eq car-type '*) (typep (car x) car-type))
+       (or (eq cdr-type '*) (typep (cdr x) cdr-type))
+  )
+  `(AND (CONSP ,x)
+        ,@(if (eq car-type '*) '() `((TYPEP (CAR ,x) ',car-type)))
+        ,@(if (eq cdr-type '*) '() `((TYPEP (CDR ,x) ',cdr-type)))
+   )
+)
+
+(fmakunbound 'def-compound-type)
+
+;; ----------------------------------------------------------------------------
+
+; Typtest ohne Gefahr einer Fehlermeldung. Für SIGNAL und HANDLER-BIND.
+(defun safe-typep (x y &optional env)
+  (let ((*error-handler*
+          #'(lambda (&rest error-args)
+              (declare (ignore error-args))
+              (return-from safe-typep (values nil nil))
+       ))   )
+    (values (typep x y env) t)
+) )
+
+; Umwandlung eines "type for declaration" in einen "type for discrimination".
+(defun type-for-discrimination (y &optional (notp nil) &aux f)
+  (cond ((symbolp y)
+           (cond ((get y 'TYPE-SYMBOL) y)
+                 ((get y 'TYPE-LIST) y)
+                 ((setq f (get y 'DEFTYPE-EXPANDER))
+                  (let* ((z (funcall f (list y)))
+                         (zx (type-for-discrimination z notp)))
+                    (if (eql zx z) y zx)
+                 ))
+                 (t y)
+        )  )
+        ((and (consp y) (symbolp (first y)))
+           (case (first y)
+             ((SATISFIES MEMBER EQL) y)
+             (NOT
+              (let* ((z (second y))
+                     (zx (type-for-discrimination z (not notp))))
+                (if (eql zx z) y `(NOT ,zx))
+             ))
+             ((AND OR COMPLEX VALUES)
+              (let* ((z (rest y))
+                     (zx (mapcar #'(lambda (x) (type-for-discrimination x notp)) z)))
+                (if (every #'eql z zx) y (cons (first y) zx))
+             ))
+             (FUNCTION
+              ;; (FUNCTION arg-types res-type) is somewhere between
+              ;; NIL and FUNCTION, but undecidable.
+              (if notp 'NIL 'FUNCTION)
+             )
+             (t (cond ((get (first y) 'TYPE-LIST) y)
+                      ((setq f (get (first y) 'DEFTYPE-EXPANDER))
+                       (let* ((z (funcall f y))
+                              (zx (type-for-discrimination z notp)))
+                         (if (eql zx z) y zx)
+                      ))
+                      (t y)
+        )  ) )  )
+        (t y)
+) )
+
+; Testet eine Liste von Werten auf Erfüllen eines Type-Specifiers. Für THE.
+(defun %the (values type) ; ABI
+  (macrolet ((near-typep (objform typform)
+               ;; near-typep ist wie typep, nur dass das Objekt auch ein
+               ;; Read-Label sein darf. Das tritt z.B. auf bei
+               ;; (read-from-string "#1=#S(FOO :X #1#)")
+               ;; im Konstruktor MAKE-FOO. Die Implementation ist aber
+               ;; nicht gezwungen, bei fehlerhaftem THE zwingend einen
+               ;; Fehler zu melden, darum ist ein lascherer Typcheck hier
+               ;; erlaubt.
+               (let ((g (gensym)))
+                 `(let ((,g ,objform))
+                    (or (typep ,g ,typform) (eq (type-of ,g) 'READ-LABEL))))))
+    (if (and (consp type) (eq (car type) 'VALUES))
+      ;; The VALUES type specifier is ill-defined in ANSI CL.
+      ;;
+      ;; There are two possibilities to define a VALUES type specifier in a
+      ;; sane way:
+      ;; - (EXACT-VALUES type1 ... [&optional ...]) describes the exact shape
+      ;;   of the values list, as received by MULTIPLE-VALUE-LIST.
+      ;;   For example, (EXACT-VALUES SYMBOL) is matched by (values 'a) but not
+      ;;   by (values 'a 'b) or (values).
+      ;; - (ASSIGNABLE-VALUES type1 ... [&optional ...]) describes the values
+      ;;   as received by a set of variables through MULTIPLE-VALUE-BIND or
+      ;;   MULTIPLE-VALUE-SETQ. For example, (ASSIGNABLE-VALUES SYMBOL) is
+      ;;   defined by whether
+      ;;     (MULTIPLE-VALUE-BIND (var1) values (DECLARE (TYPE SYMBOL var1)) ...)
+      ;;   is valid or not; therefore (ASSIGNABLE-VALUES SYMBOL) is matched by
+      ;;   (values 'a) and (values 'a 'b) and (values).
+      ;;   Note that &OPTIONAL is actually redundant here:
+      ;;     (ASSIGNABLE-VALUES type1 ... &optional otype1 ...)
+      ;;   is equivalent to
+      ;;     (ASSIGNABLE-VALUES type1 ... (OR NULL otype1) ...)
+      ;; HyperSpec/Body/typspe_values.html indicates that VALUES means
+      ;; EXACT-VALUES; however, HyperSpec/Body/speope_the.html indicates that
+      ;; VALUES means ASSIGNABLE-VALUES.
+      ;;
+      ;; SBCL interprets the VALUES type specifier to mean EXACT-VALUES when
+      ;; it contains &OPTIONAL or &REST, but ASSIGNABLE-VALUES when it has
+      ;; only a tuple of type specifiers. This is utter nonsense, in particular
+      ;; because it makes (VALUES type1 ... typek &OPTIONAL)
+      ;; different from   (VALUES type1 ... typek).
+      ;;
+      ;; Here we use the ASSIGNABLE-VALUES interpretation.
+      ;; In SUBTYPEP we just punt and don't assume any interpretation.
+      (let ((vals values) (types (cdr type)))
+        ;; required:
+        (loop
+          (when (or (atom types) (atom vals)) (return-from %the t))
+          (when (memq (car types) lambda-list-keywords) (return))
+          (unless (near-typep (pop vals) (pop types))
+            (return-from %the nil)))
+        ;; &optional:
+        (when (and (consp types) (eq (car types) '&optional))
+          (setq types (cdr types))
+          (loop
+            (when (or (atom types) (atom vals)) (return-from %the t))
+            (when (memq (car types) lambda-list-keywords) (return))
+            (unless (near-typep (pop vals) (pop types))
+              (return-from %the nil))))
+        ;; &rest &key:
+        (case (car types)
+          (&rest
+           (setq types (cdr types))
+           (when (atom types) (typespec-error 'the type))
+           (unless (near-typep (pop vals) (pop types))
+             (return-from %the nil)))
+          (&key)
+          (t (typespec-error 'the type)))
+        (if (eq (car types) '&key)
+          (progn
+            (setq types (cdr types))
+            (when (oddp (length vals)) (return-from %the nil))
+            (let ((keywords nil))
+              (loop
+                (when (or (atom types) (atom vals)) (return-from %the t))
+                (when (memq (car types) lambda-list-keywords) (return))
+                (let ((item (pop types)))
+                  (unless (and (listp item) (eql (length item) 2)
+                               (symbolp (first item)))
+                    (typespec-error 'the type))
+                  (let ((kw (symbol-to-keyword (first item))))
+                    (unless (near-typep (getf vals kw) (second item))
+                      (return-from %the nil))
+                    (push kw keywords))))
+              (if (and (consp types) (eq (car types) '&allow-other-keys))
+                (setq types (cdr types))
+                (unless (getf vals ':allow-other-keys)
+                  (do ((L vals (cddr L)))
+                      ((atom L))
+                    (unless (memq (car L) keywords)
+                      (return-from %the nil)))))))
+          (when (consp types) (typespec-error 'the type)))
+        t)
+      (near-typep (if (consp values) (car values) nil) type))))
+
+;;; ===========================================================================
+
+;; SUBTYPEP
+(load "subtypep")
+
+
+;; Returns the number of bytes that are needed to represent #\Null in a
+;; given encoding.
+(defun encoding-zeroes (encoding)
+  #+UNICODE
+  ;; this should use min_bytes_per_char for cache, not the hash table
+  (let ((name (ext:encoding-charset encoding))
+        (table #.(make-hash-table :key-type '(or string symbol) :value-type 'fixnum
+                                  :test 'stablehash-equal :warn-if-needs-rehash-after-gc t
+                                  :initial-contents '(("UTF-7" . 1))))
+        (tester #.(make-string 2 :initial-element (code-char 0))))
+    (or (gethash name table)
+        (setf (gethash name table)
+              (- (length (ext:convert-string-to-bytes tester encoding))
+                 (length (ext:convert-string-to-bytes tester encoding
+                                                      :end 1))))))
+  #-UNICODE 1)
+
+;; Determines two values low,high such that
+;;   (subtypep type `(INTEGER ,low ,high))
+;; holds and low is as large as possible and high is as small as possible.
+;; low = * means -infinity, high = * means infinity.
+;; When (subtypep type 'INTEGER) is false, the values NIL,NIL are returned.
+;; We need this function only for MAKE-ARRAY, UPGRADED-ARRAY-ELEMENT-TYPE and
+;; OPEN and can therefore w.l.o.g. replace
+;;   type  with  `(OR ,type (MEMBER 0))
+#| ;; The original implementation calls canonicalize-type and then applies
+   ;; a particular SUBTYPE variant:
+ (defun subtype-integer (type)
+  (macrolet ((yes () '(return-from subtype-integer (values low high)))
+             (no () '(return-from subtype-integer nil))
+             (unknown () '(return-from subtype-integer nil)))
+    (setq type (canonicalize-type type))
+    (if (consp type)
+      (case (first type)
+        (MEMBER ; (MEMBER &rest objects)
+          ;; All elements must be of type INTEGER.
+          (let ((low 0) (high 0)) ; wlog!
+            (dolist (x (rest type) (yes))
+              (unless (typep x 'INTEGER) (return (no)))
+              (setq low (min low x) high (max high x)))))
+        (OR ; (OR type*)
+          ;; Every type must be subtype of INTEGER.
+          (let ((low 0) (high 0)) ; wlog!
+            (dolist (type1 (rest type) (yes))
+              (multiple-value-bind (low1 high1) (subtype-integer type1)
+                (unless low1 (return (no)))
+                (setq low (if (or (eq low '*) (eq low1 '*)) '* (min low low1))
+                      high (if (or (eq high '*) (eq high1 '*))
+                               '* (max high high1)))))))
+        (AND ; (AND type*)
+          ;; If one of the types is subtype of INTEGER, then yes,
+          ;; otherwise unknown.
+          (let ((low nil) (high nil))
+            (dolist (type1 (rest type))
+              (multiple-value-bind (low1 high1) (subtype-integer type1)
+                (when low1
+                  (if low
+                    (setq low (if (eq low '*) low1 (if (eq low1 '*) low (max low low1)))
+                          high (if (eq high '*) high1 (if (eq high1 '*) high (min high high1))))
+                    (setq low low1 high high1)))))
+            (if low
+              (progn
+                (when (and (numberp low) (numberp high) (not (<= low high)))
+                  (setq low 0 high 0) ; type equivalent to NIL)
+                (yes))
+              (unknown)))))
+      (setq type (list type)))
+    (if (eq (first type) 'INTEGER)
+      (let ((low (if (rest type) (second type) '*))
+            (high (if (cddr type) (third type) '*)))
+        (when (consp low)
+          (setq low (first low))
+          (when (numberp low) (incf low)))
+        (when (consp high)
+          (setq high (first high))
+          (when (numberp high) (decf high)))
+        (when (and (numberp low) (numberp high) (not (<= low high))) ; type leer?
+          (setq low 0 high 0))
+        (yes))
+      (if (and (eq (first type) 'INTERVALS) (eq (second type) 'INTEGER))
+        (let ((low (third type))
+              (high (car (last type))))
+          (when (consp low)
+            (setq low (first low))
+            (when (numberp low) (incf low)))
+          (when (consp high)
+            (setq high (first high))
+            (when (numberp high) (decf high)))
+          (yes))
+        (unknown)))))
+|# ;; This implementation inlines the (tail-recursive) canonicalize-type
+   ;; function. Its advantage is that it doesn't cons as much.
+   ;; (For example, (subtype-integer '(UNSIGNED-BYTE 8)) doesn't cons.)
+(defun subtype-integer (type)
+  (macrolet ((yes () '(return-from subtype-integer (values low high)))
+             (no () '(return-from subtype-integer nil))
+             (unknown () '(return-from subtype-integer nil)))
+    (setq type (expand-deftype type))
+    (cond ((symbolp type)
+           (case type
+             (BIT (let ((low 0) (high 1)) (yes)))
+             (FIXNUM
+              (let ((low '#,most-negative-fixnum)
+                    (high '#,most-positive-fixnum))
+                (yes)))
+             ((INTEGER BIGNUM SIGNED-BYTE)
+              (let ((low '*) (high '*)) (yes)))
+             (UNSIGNED-BYTE
+              (let ((low 0) (high '*)) (yes)))
+             ((NIL)
+              (let ((low 0) (high 0)) (yes))) ; wlog!
+             (t (no))))
+          ((and (consp type) (symbolp (first type)))
+           (unless (and (list-length type) (null (cdr (last type))))
+             (typespec-error 'subtypep type))
+           (case (first type)
+             (MEMBER ; (MEMBER &rest objects)
+              ;; All elements must be of type INTEGER.
+              (let ((low 0) (high 0)) ; wlog!
+                (dolist (x (rest type) (yes))
+                  (unless (typep x 'INTEGER) (return (no)))
+                  (setq low (min low x) high (max high x)))))
+             (EQL ; (EQL object)
+              (let ((x (second type)))
+                (if (typep x 'INTEGER)
+                  (let ((low (min 0 x)) (high (max 0 x))) (yes))
+                  (no))))
+             (OR ; (OR type*)
+              ;; Every type must be subtype of INTEGER.
+              (let ((low 0) (high 0)) ; wlog!
+                (dolist (type1 (rest type) (yes))
+                  (multiple-value-bind (low1 high1) (subtype-integer type1)
+                    (unless low1 (return (no)))
+                    (setq low (if (or (eq low '*) (eq low1 '*))
+                                  '* (min low low1))
+                          high (if (or (eq high '*) (eq high1 '*))
+                                   '* (max high high1)))))))
+             (AND ; (AND type*)
+              ;; If one of the types is subtype of INTEGER, then yes,
+              ;; otherwise unknown.
+              (let ((low nil) (high nil))
+                (dolist (type1 (rest type))
+                  (multiple-value-bind (low1 high1) (subtype-integer type1)
+                    (when low1
+                      (if low
+                        (setq low (if (eq low '*) low1
+                                      (if (eq low1 '*) low
+                                          (max low low1)))
+                              high (if (eq high '*) high1
+                                       (if (eq high1 '*) high
+                                           (min high high1))))
+                        (setq low low1
+                              high high1)))))
+                (if low
+                  (progn
+                    (when (and (numberp low) (numberp high)
+                               (not (<= low high)))
+                      (setq low 0 high 0)) ; type equivalent to NIL
+                    (yes))
+                  (unknown))))
+             (INTEGER
+              (let ((low (if (rest type) (second type) '*))
+                    (high (if (cddr type) (third type) '*)))
+                (when (consp low)
+                  (setq low (first low))
+                  (when (numberp low) (incf low)))
+                (when (consp high)
+                  (setq high (first high))
+                  (when (numberp high) (decf high)))
+                (when (and (numberp low) (numberp high) (not (<= low high)))
+                  (setq low 0 high 0)) ; type equivalent to NIL
+                (yes)))
+             (INTERVALS
+              (if (eq (second type) 'INTEGER)
+                (let ((low (third type))
+                      (high (car (last type))))
+                  (when (consp low)
+                    (setq low (first low))
+                    (when (numberp low) (incf low)))
+                  (when (consp high)
+                    (setq high (first high))
+                    (when (numberp high) (decf high)))
+                  (yes))
+                (unknown)))
+             (MOD ; (MOD n)
+              (let ((n (second type)))
+                (unless (and (integerp n) (>= n 0))
+                  (typespec-error 'subtypep type))
+                (if (eql n 0)
+                  (no)
+                  (let ((low 0) (high (1- n)))
+                    (yes)))))
+             (SIGNED-BYTE ; (SIGNED-BYTE &optional s)
+              (let ((s (if (cdr type) (second type) '*)))
+                (if (eq s '*)
+                  (let ((low '*) (high '*)) (yes))
+                  (progn
+                    (unless (and (integerp s) (plusp s))
+                      (typespec-error 'subtypep type))
+                    (let ((n (ash 1 (1- s)))) ; (ash 1 *) == (expt 2 *)
+                      (let ((low (- n)) (high (1- n)))
+                        (yes)))))))
+             (UNSIGNED-BYTE ; (UNSIGNED-BYTE &optional s)
+              (let ((s (if (cdr type) (second type) '*)))
+                (if (eq s '*)
+                    (let ((low 0) (high '*)) (yes))
+                    (progn
+                      (unless (and (integerp s) (>= s 0))
+                        (typespec-error 'subtypep type))
+                      (let ((n (ash 1 s))) ; (ash 1 *) == (expt 2 *)
+                        (let ((low 0) (high (1- n)))
+                          (yes)))))))
+             (t (no))))
+          ((clos::defined-class-p type)
+           (if (and (clos::built-in-class-p type)
+                    (eq (get (clos:class-name type) 'CLOS::CLOSCLASS) type))
+             (return-from subtype-integer
+               (subtype-integer (clos:class-name type)))
+             (no)))
+          ((clos::eql-specializer-p type)
+           (let ((x (clos::eql-specializer-singleton type)))
+             (if (typep x 'INTEGER)
+               (let ((low (min 0 x)) (high (max 0 x))) (yes))
+               (no))))
+          ((encodingp type) (no))
+          (t (typespec-error 'subtypep type)))))
+
+#| TODO: Fix subtype-integer such that this works.
+Henry Baker:
+ (defun type-null (x)
+  (values (and (eq 'bit (upgraded-array-element-type `(or bit ,x)))
+               (not (typep 0 x))
+               (not (typep 1 x)))
+          t))
+ (type-null '(and symbol number))
+ (type-null '(and integer symbol))
+ (type-null '(and integer character))
+|#
+
+;; Determines a sequence kind (an atom, as defined in defseq.lisp: one of
+;;   LIST - stands for LIST
+;;   VECTOR - stands for (VECTOR T)
+;;   STRING - stands for (VECTOR CHARACTER)
+;;   1, 2, 4, 8, 16, 32 - stands for (VECTOR (UNSIGNED-BYTE n))
+;;   0 - stands for (VECTOR NIL))
+;; that indicates the sequence type meant by the given type. Other possible
+;; return values are
+;;   SEQUENCE - denoting a type whose intersection with (OR LIST VECTOR) is not
+;;              subtype of LIST or VECTOR, or
+;;   NIL - indicating a type whose intersection with (OR LIST VECTOR) is empty.
+;; When the type is (OR (VECTOR eltype1) ... (VECTOR eltypeN)), the chosen
+;; element type is the smallest element type that contains all of eltype1 ...
+;; eltypeN.
+;;
+;; User-defined sequence types are not supported here.
+;;
+;; This implementation inlines the (tail-recursive) canonicalize-type
+;; function. Its advantage is that it doesn't cons as much. Also it employs
+;; some heuristics and does not have the full power of SUBTYPEP.
+(defun subtype-sequence (type)
+  (setq type (expand-deftype type))
+  (cond ((symbolp type)
+         (case type
+           ((LIST CONS NULL) 'LIST)
+           ((NIL) 'NIL)
+           ((BIT-VECTOR SIMPLE-BIT-VECTOR) '1)
+           ((STRING SIMPLE-STRING BASE-STRING SIMPLE-BASE-STRING) 'STRING)
+           ((VECTOR SIMPLE-VECTOR ARRAY SIMPLE-ARRAY) 'VECTOR)
+           ((SEQUENCE) 'SEQUENCE)
+           (t 'NIL)))
+        ((and (consp type) (symbolp (first type)))
+         (unless (and (list-length type) (null (cdr (last type))))
+           (typespec-error 'subtypep type))
+         (case (first type)
+           (MEMBER ; (MEMBER &rest objects)
+            (let ((kind 'NIL))
+              (dolist (x (rest type))
+                (setq kind (sequence-type-union kind (type-of-sequence x))))
+              kind))
+           (EQL ; (EQL object)
+            (unless (eql (length type) 2)
+              (typespec-error 'subtypep type))
+            (type-of-sequence (second type)))
+           (OR ; (OR type*)
+            (let ((kind 'NIL))
+              (dolist (x (rest type))
+                (setq kind (sequence-type-union kind (subtype-sequence x))))
+              kind))
+           (AND ; (AND type*)
+            (let ((kind 'SEQUENCE))
+              (dolist (x (rest type))
+                (setq kind (sequence-type-intersection kind (subtype-sequence x))))
+              kind))
+           ((SIMPLE-BIT-VECTOR BIT-VECTOR) ; (SIMPLE-BIT-VECTOR &optional size)
+            (when (cddr type)
+              (typespec-error 'subtypep type))
+            '1)
+           ((SIMPLE-STRING STRING SIMPLE-BASE-STRING BASE-STRING) ; (SIMPLE-STRING &optional size)
+            (when (cddr type)
+              (typespec-error 'subtypep type))
+            'STRING)
+           (SIMPLE-VECTOR ; (SIMPLE-VECTOR &optional size)
+            (when (cddr type)
+              (typespec-error 'subtypep type))
+            'VECTOR)
+           ((VECTOR ARRAY SIMPLE-ARRAY) ; (VECTOR &optional el-type size), (ARRAY &optional el-type dimensions)
+            (when (cdddr type)
+              (typespec-error 'subtypep type))
+            (let ((el-type (if (cdr type) (second type) '*)))
+              (if (eq el-type '*)
+                'VECTOR
+                (let ((eltype (upgraded-array-element-type el-type)))
+                  (cond ((eq eltype 'T) 'VECTOR)
+                        ((eq eltype 'CHARACTER) 'STRING)
+                        ((eq eltype 'BIT) '1)
+                        ((and (consp eltype) (eq (first eltype) 'UNSIGNED-BYTE)) (second eltype))
+                        ((eq eltype 'NIL) '0)
+                        (t (error (TEXT "~S is not up-to-date with ~S for element type ~S")
+                                  'subtypep-sequence 'upgraded-array-element-type eltype)))))))
+           ((CONS) ; (CONS &optional cartype cdrtype)
+            (when (cdddr type)
+              (typespec-error 'subtypep type))
+            'LIST)
+           (t 'NIL)))
+        ((clos::defined-class-p type)
+         (if (and (clos::built-in-class-p type)
+                  (eq (get (clos:class-name type) 'CLOS::CLOSCLASS) type))
+           (subtype-sequence (clos:class-name type))
+           'NIL))
+        ((clos::eql-specializer-p type)
+         (type-of-sequence (clos::eql-specializer-singleton type)))
+        (t 'NIL)))
+(defun type-of-sequence (x)
+  (cond ((listp x) 'LIST)
+        ((vectorp x)
+         (let ((eltype (array-element-type x)))
+           (cond ((eq eltype 'T) 'VECTOR)
+                 ((eq eltype 'CHARACTER) 'STRING)
+                 ((eq eltype 'BIT) '1)
+                 ((and (consp eltype) (eq (first eltype) 'UNSIGNED-BYTE)) (second eltype))
+                 ((eq eltype 'NIL) '0)
+                 (t (error (TEXT "~S is not up-to-date with ~S for element type ~S")
+                           'type-of-sequence 'array-element-type eltype)))))
+        (t 'NIL)))
+(defun sequence-type-union (t1 t2)
+  (cond ; Simple general rules.
+        ((eql t1 t2) t1)
+        ((eq t1 'NIL) t2)
+        ((eq t2 'NIL) t1)
+        ; Now the union of two different types.
+        ((or (eq t1 'SEQUENCE) (eq t2 'SEQUENCE)) 'SEQUENCE)
+        ((or (eq t1 'LIST) (eq t2 'LIST))
+         ; union of LIST and a vector type
+         'SEQUENCE)
+        ((or (eq t1 'VECTOR) (eq t2 'VECTOR)) 'VECTOR)
+        ((eql t1 0) t2)
+        ((eql t2 0) t1)
+        ((or (eq t1 'STRING) (eq t2 'STRING))
+         ; union of STRING and an integer-vector type
+         'VECTOR)
+        (t (max t1 t2))))
+(defun sequence-type-intersection (t1 t2)
+  (cond ; Simple general rules.
+        ((eql t1 t2) t1)
+        ((or (eq t1 'NIL) (eq t2 'NIL)) 'NIL)
+        ; Now the intersection of two different types.
+        ((eq t1 'SEQUENCE) t2)
+        ((eq t2 'SEQUENCE) t1)
+        ((or (eq t1 'LIST) (eq t2 'LIST))
+         ; intersection of LIST and a vector type
+         'NIL)
+        ((eq t1 'VECTOR) t2)
+        ((eq t2 'VECTOR) t1)
+        ((or (eql t1 0) (eql t2 0)) '0)
+        ((or (eq t1 'STRING) (eq t2 'STRING))
+         ; intersection of STRING and an integer-vector type
+         '0)
+        (t (min t1 t2))))
+
+;; ============================================================================
+
+(defun type-expand (typespec &optional once-p)
+  (multiple-value-bind (expanded user-defined-p)
+      (expand-deftype typespec once-p)
+    (if user-defined-p (values expanded user-defined-p)
+      (cond ((symbolp typespec)
+             (cond ((or (get typespec 'TYPE-SYMBOL) (get typespec 'TYPE-LIST))
+                    (values typespec nil))
+                   ((or (get typespec 'DEFSTRUCT-DESCRIPTION)
+                        (clos-class typespec))
+                    (values typespec nil))
+                   (t (typespec-error 'type-expand typespec))))
+            ((and (consp typespec) (symbolp (first typespec)))
+             (case (first typespec)
+               ((SATISFIES MEMBER EQL NOT AND OR) (values typespec nil))
+               (t (cond ((get (first typespec) 'TYPE-LIST)
+                         (values typespec nil))
+                        (t (typespec-error 'type-expand typespec))))))
+            ((clos::defined-class-p typespec) (values typespec nil))
+            (t (typespec-error 'type-expand typespec))))))
+
+;; ============================================================================
+
+(unless (clos::funcallable-instance-p #'clos::class-name)
+  (fmakunbound 'clos::class-name))
+
+
+(keywordp :junk)
+  T
+
+(keywordp ::junk)
+  T
+
+(symbol-name ::junk)
+  "JUNK"
+
+(symbol-name :#junk)
+  "#JUNK"
+
+(symbol-name :#.junk)
+  "#.JUNK"
+
+---tokens---
+';;;; TYPEP und Verwandtes' Comment.Single
+'\n'          Text
+
+';;;; Michael Stoll, 21. 10. 1988' Comment.Single
+'\n'          Text
+
+';;;; Bruno Haible, 10.6.1989' Comment.Single
+'\n'          Text
+
+';;;; Sam Steingold 2000-2005' Comment.Single
+'\n\n'        Text
+
+';;; Datenstrukturen für TYPEP:' Comment.Single
+'\n'          Text
+
+';;; - Ein Type-Specifier-Symbol hat auf seiner Propertyliste unter dem' Comment.Single
+'\n'          Text
+
+';;;   Indikator SYS::TYPE-SYMBOL eine Funktion von einem Argument, die' Comment.Single
+'\n'          Text
+
+';;;   testet, ob ein Objekt vom richtigen Typ ist.' Comment.Single
+'\n'          Text
+
+';;; - Ein Symbol, das eine Type-Specifier-Liste beginnen kann, hat auf seiner' Comment.Single
+'\n'          Text
+
+';;;   Propertyliste unter dem Indikator SYS::TYPE-LIST eine Funktion von' Comment.Single
+'\n'          Text
+
+';;;   einem Argument für das zu testende Objekt und zusätzlichen Argumenten' Comment.Single
+'\n'          Text
+
+';;;   für die Listenelemente.' Comment.Single
+'\n'          Text
+
+';;; - Ein Symbol, das als Typmacro definiert wurde, hat auf seiner Property-' Comment.Single
+'\n'          Text
+
+';;;   liste unter dem Indikator SYSTEM::DEFTYPE-EXPANDER den zugehörigen' Comment.Single
+'\n'          Text
+
+';;;   Expander: eine Funktion, die den zu expandierenden Type-Specifier (eine' Comment.Single
+'\n'          Text
+
+';;;   mindestens einelementige Liste) als Argument bekommt.' Comment.Single
+'\n\n'        Text
+
+'('           Punctuation
+'in-package'  Name.Builtin
+' '           Text
+'"EXT"'       Literal.String
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'export'      Name.Builtin
+' '           Text
+"'"           Operator
+'('           Punctuation
+'type-expand' Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'in-package'  Name.Builtin
+' '           Text
+'"SYSTEM"'    Literal.String
+')'           Punctuation
+'\n\n'        Text
+
+'; vorläufig, solange bis clos.lisp geladen wird:' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'eval-when'   Keyword
+' '           Text
+'('           Punctuation
+'eval'        Name.Builtin
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'predefun'    Name.Variable
+' '           Text
+'clos::built-in-class-p' Name.Variable
+' '           Text
+'('           Punctuation
+'object'      Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'object'      Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'fboundp'     Name.Builtin
+' '           Text
+"'clos::class-name" Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'clos::class-name' Name.Variable
+' '           Text
+'('           Punctuation
+'c'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'c'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n\n'        Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'typespec-error' Name.Variable
+' '           Text
+'('           Punctuation
+'fun'         Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'error-of-type' Name.Variable
+' '           Text
+"'error"      Literal.String.Symbol
+'\n    '      Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: invalid type specification ~S"' Literal.String
+')'           Punctuation
+'\n    '      Text
+'fun'         Name.Variable
+' '           Text
+'type'        Keyword
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n\n'        Text
+
+';; ============================================================================' Comment.Single
+'\n\n'        Text
+
+';; return the CLOS class named by TYPESPEC or NIL' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'clos-class'  Name.Variable
+' '           Text
+'('           Punctuation
+'typespec'    Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'cc'          Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+"'CLOS::CLOSCLASS" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'cc'          Name.Variable
+' '           Text
+'('           Punctuation
+'clos::defined-class-p' Name.Variable
+' '           Text
+'cc'          Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'clos:class-name' Name.Variable
+' '           Text
+'cc'          Name.Variable
+')'           Punctuation
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n      '    Text
+'cc'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+';;; TYPEP, CLTL S. 72, S. 42-51' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'typep'       Name.Builtin
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'y'           Name.Variable
+' '           Text
+'&optional'   Keyword
+' '           Text
+'env'         Name.Variable
+' '           Text
+'&aux'        Keyword
+' '           Text
+'f'           Name.Variable
+')'           Punctuation
+' '           Text
+'; x = Objekt, y = Typ' Comment.Single
+'\n  '        Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'env'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'y'           Name.Variable
+' '           Text
+'('           Punctuation
+'expand-deftype' Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'cond'        Name.Builtin
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'y'           Name.Variable
+' '           Text
+"'TYPE-SYMBOL" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'f'           Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'y'           Name.Variable
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'f'           Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'y'           Name.Variable
+' '           Text
+"'DEFSTRUCT-DESCRIPTION" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'ds-typep'    Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'y'           Name.Variable
+' '           Text
+'f'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'clos-class'  Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+"; It's not worth handling structure classes specially here." Comment.Single
+'\n              ' Text
+'('           Punctuation
+'clos::typep-class' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'f'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'cond'        Name.Builtin
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'SATISFIES"  Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'error-of-type' Name.Variable
+' '           Text
+"'error"      Literal.String.Symbol
+'\n                ' Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: argument to SATISFIES must be a symbol: ~S"' Literal.String
+')'           Punctuation
+'\n                ' Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n            ' Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'('           Punctuation
+'symbol-function' Name.Builtin
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'t'           Name.Constant
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n         ' Text
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'MEMBER"     Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'member'      Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'t'           Name.Constant
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n         ' Text
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'EQL"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'NOT"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'AND"        Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'type'        Keyword
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'OR"         Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'type'        Keyword
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'apply'       Name.Builtin
+' '           Text
+'f'           Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'clos::defined-class-p' Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'clos::typep-class' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'clos::eql-specializer-p' Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'clos::eql-specializer-singleton' Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'encodingp'   Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'charset-typep' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n\n'        Text
+
+';; ----------------------------------------------------------------------------' Comment.Single
+'\n\n'        Text
+
+';; UPGRADED-ARRAY-ELEMENT-TYPE is a lattice homomorphism, see' Comment.Single
+'\n'          Text
+
+';; ANSI CL 15.1.2.1.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'('           Punctuation
+'type'        Keyword
+' '           Text
+'&optional'   Keyword
+' '           Text
+'environment' Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'environment' Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+';; see array.d' Comment.Single
+'\n  '        Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'type'        Keyword
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'BIT'         Name.Variable
+')'           Punctuation
+' '           Text
+"'BIT"        Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'CHARACTER'   Name.Variable
+')'           Punctuation
+' '           Text
+"'CHARACTER"  Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'T'           Name.Constant
+')'           Punctuation
+' '           Text
+"'T"          Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'('           Punctuation
+'NIL'         Name.Constant
+')'           Punctuation
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'subtypep'    Name.Builtin
+' '           Text
+'type'        Keyword
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+'\n         ' Text
+"'NIL"        Literal.String.Symbol
+'\n         ' Text
+'('           Punctuation
+'multiple-value-bind' Name.Builtin
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'sys::subtype-integer' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n           ' Text
+'; Es gilt (or (null low) (subtypep type `(INTEGER ,low ,high)))' Comment.Single
+'\n           ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'minusp'      Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'l'           Name.Variable
+' '           Text
+'('           Punctuation
+'integer-length' Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n               ' Text
+'; Es gilt (subtypep type `(UNSIGNED-BYTE ,l))' Comment.Single
+'\n               ' Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'l'           Name.Variable
+' '           Text
+'1'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"'BIT"        Literal.String.Symbol
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'l'           Name.Variable
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'l'           Name.Variable
+' '           Text
+'4'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'4'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'l'           Name.Variable
+' '           Text
+'8'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'8'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'l'           Name.Variable
+' '           Text
+'16'          Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'16'          Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'l'           Name.Variable
+' '           Text
+'32'          Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'32'          Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+"'T"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'subtypep'    Name.Builtin
+' '           Text
+'type'        Keyword
+' '           Text
+"'CHARACTER"  Literal.String.Symbol
+')'           Punctuation
+'\n               ' Text
+"'CHARACTER"  Literal.String.Symbol
+'\n               ' Text
+"'T"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+';; ----------------------------------------------------------------------------' Comment.Single
+'\n\n'        Text
+
+';; UPGRADED-COMPLEX-PART-TYPE is a lattice homomorphism, see' Comment.Single
+'\n'          Text
+
+';; HyperSpec/Body/fun_complex.html and HyperSpec/Body/syscla_complex.html,' Comment.Single
+'\n'          Text
+
+';; and an idempotent. Therefore' Comment.Single
+'\n'          Text
+
+';;   (subtypep (upgraded-complex-part-type T1) (upgraded-complex-part-type T2))' Comment.Single
+'\n'          Text
+
+';; is equivalent to' Comment.Single
+'\n'          Text
+
+';;   (subtypep T1 (upgraded-complex-part-type T2))' Comment.Single
+'\n'          Text
+
+';; (Proof: Let U T be an abbreviation for (upgraded-complex-part-type T).' Comment.Single
+'\n'          Text
+
+';;  If U T1 <= U T2, then T1 <= U T1 <= U T2.' Comment.Single
+'\n'          Text
+
+';;  If T1 <= U T2, then by homomorphism U T1 <= U U T2 = U T2.)' Comment.Single
+'\n'          Text
+
+';;'          Comment.Single
+'\n'          Text
+
+';; For _any_ CL implementation, you could define' Comment.Single
+'\n'          Text
+
+";;   (defun upgraded-complex-part-type (type) 'REAL)" Comment.Single
+'\n'          Text
+
+';; Likewise for _any_ CL implementation, you could define' Comment.Single
+'\n'          Text
+
+';;   (defun upgraded-complex-part-type (type) type)' Comment.Single
+'\n'          Text
+
+';; or - again for _any_ CL implementation:' Comment.Single
+'\n'          Text
+
+';;   (defun upgraded-complex-part-type (type)' Comment.Single
+'\n'          Text
+
+";;     (cond ((subtypep type 'NIL) 'NIL)" Comment.Single
+'\n'          Text
+
+";;           ((subtypep type 'SHORT-FLOAT) 'SHORT-FLOAT)" Comment.Single
+'\n'          Text
+
+";;           ((subtypep type 'SINGLE-FLOAT) 'SINGLE-FLOAT)" Comment.Single
+'\n'          Text
+
+";;           ((subtypep type 'DOUBLE-FLOAT) 'DOUBLE-FLOAT)" Comment.Single
+'\n'          Text
+
+";;           ((subtypep type 'LONG-FLOAT) 'LONG-FLOAT)" Comment.Single
+'\n'          Text
+
+";;           ((subtypep type 'RATIONAL) 'RATIONAL)" Comment.Single
+'\n'          Text
+
+";;           ((subtypep type 'REAL) 'REAL)" Comment.Single
+'\n'          Text
+
+';;           (t (error ...))))' Comment.Single
+'\n'          Text
+
+';; The reason is that a complex number is immutable: no setters for the' Comment.Single
+'\n'          Text
+
+';; realpart and imagpart exist.' Comment.Single
+'\n'          Text
+
+';;'          Comment.Single
+'\n'          Text
+
+';; We choose the second implementation because it allows the most precise' Comment.Single
+'\n'          Text
+
+';; type inference.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'upgraded-complex-part-type' Name.Builtin
+' '           Text
+'('           Punctuation
+'type'        Keyword
+' '           Text
+'&optional'   Keyword
+' '           Text
+'environment' Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'environment' Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'subtypep'    Name.Builtin
+' '           Text
+'type'        Keyword
+' '           Text
+"'REAL"       Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'type'        Keyword
+'\n    '      Text
+'('           Punctuation
+'error-of-type' Name.Variable
+' '           Text
+"'error"      Literal.String.Symbol
+'\n      '    Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: type ~S is not a subtype of ~S"' Literal.String
+')'           Punctuation
+'\n      '    Text
+"'upgraded-complex-part-type" Literal.String.Symbol
+' '           Text
+'type'        Keyword
+' '           Text
+"'real"       Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+';; ----------------------------------------------------------------------------' Comment.Single
+'\n\n'        Text
+
+';; Macros for defining the various built-in "atomic type specifier"s and' Comment.Single
+'\n'          Text
+
+';; "compound type specifier"s. The following macros add information for both' Comment.Single
+'\n'          Text
+
+';; the TYPEP function above and the c-TYPEP in the compiler.' Comment.Single
+'\n\n'        Text
+
+'; Alist symbol -> funname, used by the compiler.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defparameter' Name.Builtin
+' '           Text
+'c-typep-alist1' Name.Variable
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'; Alist symbol -> lambdabody, used by the compiler.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defparameter' Name.Builtin
+' '           Text
+'c-typep-alist2' Name.Variable
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'; Alist symbol -> expander function, used by the compiler.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defparameter' Name.Builtin
+' '           Text
+'c-typep-alist3' Name.Variable
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+'; (def-atomic-type symbol function-name)' Comment.Single
+'\n'          Text
+
+'; defines an atomic type. The function-name designates a function taking one' Comment.Single
+'\n'          Text
+
+'; argument and returning a generalized boolean value. It can be either a' Comment.Single
+'\n'          Text
+
+'; symbol or a lambda expression.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defmacro'    Name.Builtin
+' '           Text
+'def-atomic-type' Name.Variable
+' '           Text
+'('           Punctuation
+'symbol'      Name.Class
+' '           Text
+'funname'     Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'lambdap'     Name.Variable
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'funname'     Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'funname'     Name.Variable
+')'           Punctuation
+' '           Text
+"'LAMBDA"     Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'`'           Operator
+'('           Punctuation
+'PROGN'       Name.Variable
+'\n       '   Text
+'('           Punctuation
+'SETF'        Name.Variable
+' '           Text
+'('           Punctuation
+'GET'         Name.Variable
+' '           Text
+"',symbol"    Literal.String.Symbol
+' '           Text
+"'TYPE-SYMBOL" Literal.String.Symbol
+')'           Punctuation
+'\n             ' Text
+','           Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'lambdap'     Name.Variable
+'\n                ' Text
+'`'           Operator
+'('           Punctuation
+'FUNCTION'    Name.Variable
+' '           Text
+','           Operator
+'('           Punctuation
+'concat-pnames' Name.Variable
+' '           Text
+'"TYPE-SYMBOL-"' Literal.String
+' '           Text
+'symbol'      Name.Class
+')'           Punctuation
+' '           Text
+','           Operator
+'funname'     Name.Variable
+')'           Punctuation
+'\n                ' Text
+'`'           Operator
+'('           Punctuation
+'FUNCTION'    Name.Variable
+' '           Text
+','           Operator
+'funname'     Name.Variable
+')'           Punctuation
+'\n              ' Text
+')'           Punctuation
+'\n       '   Text
+')'           Punctuation
+'\n       '   Text
+','           Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'lambdap'     Name.Variable
+'\n          ' Text
+'`'           Operator
+'('           Punctuation
+'SETQ'        Name.Variable
+' '           Text
+'C-TYPEP-ALIST2' Name.Variable
+'\n                 ' Text
+'('           Punctuation
+'NCONC'       Name.Variable
+' '           Text
+'C-TYPEP-ALIST2' Name.Variable
+' '           Text
+'('           Punctuation
+'LIST'        Name.Variable
+' '           Text
+'('           Punctuation
+'CONS'        Name.Variable
+' '           Text
+"',symbol"    Literal.String.Symbol
+' '           Text
+"',"          Literal.String.Symbol
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'funname'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+')'           Punctuation
+'\n          ' Text
+'`'           Operator
+'('           Punctuation
+'SETQ'        Name.Variable
+' '           Text
+'C-TYPEP-ALIST1' Name.Variable
+'\n                 ' Text
+'('           Punctuation
+'NCONC'       Name.Variable
+' '           Text
+'C-TYPEP-ALIST1' Name.Variable
+' '           Text
+'('           Punctuation
+'LIST'        Name.Variable
+' '           Text
+'('           Punctuation
+'CONS'        Name.Variable
+' '           Text
+"',symbol"    Literal.String.Symbol
+' '           Text
+"',funname"   Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+')'           Punctuation
+'\n        '  Text
+')'           Punctuation
+'\n       '   Text
+"',symbol"    Literal.String.Symbol
+'\n     '     Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n\n'        Text
+
+'; (def-compound-type symbol lambda-list (x) check-form typep-form c-typep-form)' Comment.Single
+'\n'          Text
+
+'; defines a compound type. The lambda-list is of the form (&optional ...)' Comment.Single
+'\n'          Text
+
+'; where the arguments come from the CDR of the type specifier.' Comment.Single
+'\n'          Text
+
+'; For typep-form, x is an object.' Comment.Single
+'\n'          Text
+
+'; For c-typep-form, x is a multiply evaluatable form (actually a gensym).' Comment.Single
+'\n'          Text
+
+"; check-form is a form performing error checking, may call `error'." Comment.Single
+'\n'          Text
+
+'; typep-form should return a generalized boolean value.' Comment.Single
+'\n'          Text
+
+'; c-typep-form should produce a form returning a generalized boolean value.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defmacro'    Name.Builtin
+' '           Text
+'def-compound-type' Name.Variable
+' '           Text
+'('           Punctuation
+'symbol'      Name.Class
+' '           Text
+'lambdalist'  Name.Variable
+' '           Text
+'('           Punctuation
+'var'         Name.Variable
+')'           Punctuation
+' '           Text
+'check-form'  Name.Variable
+' '           Text
+'typep-form'  Name.Variable
+' '           Text
+'c-typep-form' Name.Variable
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'PROGN'       Name.Variable
+'\n     '     Text
+'('           Punctuation
+'SETF'        Name.Variable
+' '           Text
+'('           Punctuation
+'GET'         Name.Variable
+' '           Text
+"',symbol"    Literal.String.Symbol
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'FUNCTION'    Name.Variable
+' '           Text
+','           Operator
+'('           Punctuation
+'concat-pnames' Name.Variable
+' '           Text
+'"TYPE-LIST-"' Literal.String
+' '           Text
+'symbol'      Name.Class
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'LAMBDA'      Name.Variable
+' '           Text
+'('           Punctuation
+','           Operator
+'var'         Name.Variable
+' '           Text
+',@'          Operator
+'lambdalist'  Name.Variable
+')'           Punctuation
+'\n               ' Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'check-form'  Name.Variable
+'\n                   ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'MACROLET'    Name.Variable
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'ERROR'       Name.Variable
+' '           Text
+'('           Punctuation
+'&REST'       Name.Variable
+' '           Text
+'ERROR-ARGS'  Name.Variable
+')'           Punctuation
+'\n                                  ' Text
+'('           Punctuation
+'LIST*'       Name.Variable
+' '           Text
+"'ERROR-OF-TYPE" Literal.String.Symbol
+' '           Text
+"'"           Operator
+"'ERROR"      Literal.String.Symbol
+' '           Text
+'ERROR-ARGS'  Name.Variable
+')'           Punctuation
+'\n                               ' Text
+')'           Punctuation
+')'           Punctuation
+'\n                       ' Text
+','           Operator
+'check-form'  Name.Variable
+'\n                    ' Text
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+')'           Punctuation
+'\n               ' Text
+','           Operator
+'typep-form'  Name.Variable
+'\n     '     Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n     '     Text
+'('           Punctuation
+'SETQ'        Name.Variable
+' '           Text
+'C-TYPEP-ALIST3' Name.Variable
+'\n           ' Text
+'('           Punctuation
+'NCONC'       Name.Variable
+' '           Text
+'C-TYPEP-ALIST3' Name.Variable
+'\n                  ' Text
+'('           Punctuation
+'LIST'        Name.Variable
+' '           Text
+'('           Punctuation
+'CONS'        Name.Variable
+' '           Text
+"',symbol"    Literal.String.Symbol
+'\n                              ' Text
+"#'"          Name.Function
+'('           Punctuation
+'LAMBDA'      Name.Variable
+' '           Text
+'('           Punctuation
+','           Operator
+'var'         Name.Variable
+' '           Text
+',@'          Operator
+'lambdalist'  Name.Variable
+' '           Text
+'&REST'       Name.Variable
+' '           Text
+'ILLEGAL-ARGS' Name.Variable
+')'           Punctuation
+'\n                                  ' Text
+'('           Punctuation
+'DECLARE'     Name.Variable
+' '           Text
+'('           Punctuation
+'IGNORE'      Name.Variable
+' '           Text
+'ILLEGAL-ARGS' Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                                  ' Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'check-form'  Name.Variable
+'\n                                      ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'MACROLET'    Name.Variable
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'ERROR'       Name.Variable
+' '           Text
+'('           Punctuation
+'&REST'       Name.Variable
+' '           Text
+'ERROR-ARGS'  Name.Variable
+')'           Punctuation
+'\n                                                     ' Text
+'('           Punctuation
+'LIST'        Name.Variable
+' '           Text
+"'PROGN"      Literal.String.Symbol
+'\n                                                           ' Text
+'('           Punctuation
+'LIST*'       Name.Variable
+' '           Text
+"'C-WARN"     Literal.String.Symbol
+' '           Text
+'ERROR-ARGS'  Name.Variable
+')'           Punctuation
+'\n                                                           ' Text
+"'"           Operator
+'('           Punctuation
+'THROW'       Name.Variable
+' '           Text
+"'C-TYPEP"    Literal.String.Symbol
+' '           Text
+'NIL'         Name.Constant
+')'           Punctuation
+'\n                                                  ' Text
+')'           Punctuation
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n                                          ' Text
+','           Operator
+'check-form'  Name.Variable
+'\n                                       ' Text
+')'           Punctuation
+')'           Punctuation
+'\n                                    ' Text
+')'           Punctuation
+'\n                                  ' Text
+','           Operator
+'c-typep-form' Name.Variable
+'\n                                ' Text
+')'           Punctuation
+'\n     '     Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+'      '      Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+'\n     '     Text
+"',symbol"    Literal.String.Symbol
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n\n'        Text
+
+'; CLtL1 p. 43' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ARRAY'       Name.Variable
+' '           Text
+'arrayp'      Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ATOM'        Name.Variable
+' '           Text
+'atom'        Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BASE-CHAR'   Name.Variable
+'\n  '        Text
+'#+'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+'\n  '        Text
+'characterp'  Name.Builtin
+'\n  '        Text
+'#-'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'characterp'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'base-char-p' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BASE-STRING' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'stringp'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'array-element-type' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n             ' Text
+'#+'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+' '           Text
+"'CHARACTER"  Literal.String.Symbol
+' '           Text
+'#-'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+' '           Text
+"'BASE-CHAR"  Literal.String.Symbol
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BIGNUM'      Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'fixnump'     Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BIT'         Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'1'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BIT-VECTOR'  Name.Variable
+' '           Text
+'bit-vector-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BOOLEAN'     Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+"'nil"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+"'t"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'CHARACTER'   Name.Variable
+' '           Text
+'characterp'  Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'COMPILED-FUNCTION' Name.Variable
+' '           Text
+'compiled-function-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'COMPLEX'     Name.Variable
+' '           Text
+'complexp'    Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'CONS'        Name.Variable
+' '           Text
+'consp'       Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'DOUBLE-FLOAT' Name.Variable
+' '           Text
+'double-float-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ENCODING'    Name.Variable
+' '           Text
+'encodingp'   Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'EXTENDED-CHAR' Name.Variable
+'\n  '        Text
+'#+'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n  '        Text
+'#-'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'characterp'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'base-char-p' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'FIXNUM'      Name.Variable
+' '           Text
+'fixnump'     Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'FLOAT'       Name.Variable
+' '           Text
+'floatp'      Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'FUNCTION'    Name.Variable
+' '           Text
+'functionp'   Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'HASH-TABLE'  Name.Variable
+' '           Text
+'hash-table-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'INTEGER'     Name.Variable
+' '           Text
+'integerp'    Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'KEYWORD'     Name.Variable
+' '           Text
+'keywordp'    Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'LIST'        Name.Variable
+' '           Text
+'listp'       Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'#+'          Operator
+'LOGICAL-PATHNAMES' Name.Variable
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'LOGICAL-PATHNAME' Name.Variable
+' '           Text
+'logical-pathname-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'LONG-FLOAT'  Name.Variable
+' '           Text
+'long-float-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'NIL'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'NULL'        Name.Variable
+' '           Text
+'null'        Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'NUMBER'      Name.Variable
+' '           Text
+'numberp'     Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'PACKAGE'     Name.Variable
+' '           Text
+'packagep'    Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'PATHNAME'    Name.Variable
+' '           Text
+'pathnamep'   Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'RANDOM-STATE' Name.Variable
+' '           Text
+'random-state-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'RATIO'       Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'rationalp'   Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'RATIONAL'    Name.Variable
+' '           Text
+'rationalp'   Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'READTABLE'   Name.Variable
+' '           Text
+'readtablep'  Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'REAL'        Name.Variable
+' '           Text
+'realp'       Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SEQUENCE'    Name.Variable
+' '           Text
+'sequencep'   Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SHORT-FLOAT' Name.Variable
+' '           Text
+'short-float-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SIMPLE-ARRAY' Name.Variable
+' '           Text
+'simple-array-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SIMPLE-BASE-STRING' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'simple-string-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'array-element-type' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n             ' Text
+'#+'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+' '           Text
+"'CHARACTER"  Literal.String.Symbol
+' '           Text
+'#-'          Operator
+'BASE-CHAR=CHARACTER' Name.Variable
+' '           Text
+"'BASE-CHAR"  Literal.String.Symbol
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SIMPLE-BIT-VECTOR' Name.Variable
+' '           Text
+'simple-bit-vector-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SIMPLE-STRING' Name.Variable
+' '           Text
+'simple-string-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SIMPLE-VECTOR' Name.Variable
+' '           Text
+'simple-vector-p' Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SINGLE-FLOAT' Name.Variable
+' '           Text
+'single-float-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'%standard-char-p' Name.Variable
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'characterp'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'standard-char-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; ABI'       Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'STANDARD-CHAR' Name.Variable
+' '           Text
+'%standard-char-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'CLOS:STANDARD-OBJECT' Name.Variable
+' '           Text
+'clos::std-instance-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'STREAM'      Name.Variable
+' '           Text
+'streamp'     Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'FILE-STREAM' Name.Variable
+' '           Text
+'file-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SYNONYM-STREAM' Name.Variable
+' '           Text
+'synonym-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'BROADCAST-STREAM' Name.Variable
+' '           Text
+'broadcast-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'CONCATENATED-STREAM' Name.Variable
+' '           Text
+'concatenated-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'TWO-WAY-STREAM' Name.Variable
+' '           Text
+'two-way-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ECHO-STREAM' Name.Variable
+' '           Text
+'echo-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'STRING-STREAM' Name.Variable
+' '           Text
+'string-stream-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'STRING'      Name.Variable
+' '           Text
+'stringp'     Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'STRING-CHAR' Name.Variable
+' '           Text
+'characterp'  Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'CLOS:STRUCTURE-OBJECT' Name.Variable
+' '           Text
+'clos::structure-object-p' Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'SYMBOL'      Name.Variable
+' '           Text
+'symbolp'     Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'T'           Name.Constant
+' '           Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+';; foreign1.lisp is loaded after this file,' Comment.Single
+'\n'          Text
+
+';; so these symbols are not external yet' Comment.Single
+'\n'          Text
+
+'#+'          Operator
+'ffi'         Name.Variable
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ffi::foreign-function' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+"'ffi::foreign-function" Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'type-of'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'#+'          Operator
+'ffi'         Name.Variable
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ffi::foreign-variable' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+"'ffi::foreign-variable" Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'type-of'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'#+'          Operator
+'ffi'         Name.Variable
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'ffi::foreign-address' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+"'ffi::foreign-address" Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'type-of'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+';; see lispbibl.d (#define FOREIGN) and predtype.d (TYPE-OF):' Comment.Single
+'\n'          Text
+
+'#+'          Operator
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'unix'        Name.Variable
+' '           Text
+'ffi'         Name.Variable
+' '           Text
+'affi'        Name.Variable
+' '           Text
+'win32'       Name.Variable
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'foreign-pointer' Name.Variable
+'\n  '        Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+"'foreign-pointer" Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'type-of'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'VECTOR'      Name.Variable
+' '           Text
+'vectorp'     Name.Builtin
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-atomic-type' Name.Variable
+' '           Text
+'PLIST'       Name.Variable
+'\n    '      Text
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'multiple-value-bind' Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'tail'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'list-length-dotted' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'tail'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'evenp'       Name.Builtin
+' '           Text
+'length'      Name.Builtin
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+'('           Punctuation
+'defmacro'    Name.Builtin
+' '           Text
+'ensure-dim'  Name.Variable
+' '           Text
+'('           Punctuation
+'type'        Keyword
+' '           Text
+'dim'         Name.Variable
+')'           Punctuation
+'\n  '        Text
+';; make sure DIM is a valid dimension' Comment.Single
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+','           Operator
+'dim'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+','           Operator
+'dim'         Name.Variable
+' '           Text
+'`'           Operator
+'('           Punctuation
+'INTEGER'     Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'('           Punctuation
+','           Operator
+'ARRAY-DIMENSION-LIMIT' Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n     '     Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: dimension ~S is invalid"' Literal.String
+')'           Punctuation
+' '           Text
+"',type"      Literal.String.Symbol
+' '           Text
+','           Operator
+'dim'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+'('           Punctuation
+'defmacro'    Name.Builtin
+' '           Text
+'ensure-rank' Name.Variable
+' '           Text
+'('           Punctuation
+'type'        Keyword
+' '           Text
+'rank'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+';; make sure RANK is a valid rank' Comment.Single
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+','           Operator
+'rank'        Name.Variable
+' '           Text
+'`'           Operator
+'('           Punctuation
+'INTEGER'     Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'('           Punctuation
+','           Operator
+'ARRAY-RANK-LIMIT' Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n     '     Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: rank ~S is invalid"' Literal.String
+')'           Punctuation
+' '           Text
+"',type"      Literal.String.Symbol
+' '           Text
+','           Operator
+'rank'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+'; CLtL1 p. 46-50' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'c-typep-array' Name.Variable
+' '           Text
+'('           Punctuation
+'tester'      Name.Variable
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+'dims'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+','           Operator
+'tester'      Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQUAL'       Name.Variable
+' '           Text
+'('           Punctuation
+'ARRAY-ELEMENT-TYPE' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"',"          Literal.String.Symbol
+'('           Punctuation
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n              ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+','           Operator
+'dims'        Name.Variable
+' '           Text
+'('           Punctuation
+'ARRAY-RANK'  Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+','           Operator
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'ARRAY-RANK'  Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+',@'          Operator
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'i'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'mapcap'      Name.Variable
+' '           Text
+"#'"          Name.Function
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'dim'         Name.Variable
+')'           Punctuation
+'\n                                ' Text
+'('           Punctuation
+'prog1'       Name.Builtin
+'\n                                  ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'dim'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n                                    ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n                                    ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+"',dim"       Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'ARRAY-DIMENSION' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+' '           Text
+','           Operator
+'i'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                                  ' Text
+')'           Punctuation
+'\n                                  ' Text
+'('           Punctuation
+'incf'        Name.Builtin
+' '           Text
+'i'           Name.Variable
+')'           Punctuation
+'\n                              ' Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n                            ' Text
+'dims'        Name.Variable
+'\n                  ' Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n               ' Text
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'c-typep-vector' Name.Variable
+' '           Text
+'('           Punctuation
+'tester'      Name.Variable
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+','           Operator
+'tester'      Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+"',size"      Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'ARRAY-DIMENSION' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'typep-number-test' Name.Variable
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'test'        Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'test'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'test'        Name.Variable
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'test'        Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'<'           Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n             ' Text
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'error-of-type' Name.Variable
+' '           Text
+"'error"      Literal.String.Symbol
+'\n                  ' Text
+'#1='         Operator
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: argument to ~S must be *, ~S or a list of ~S: ~S"' Literal.String
+')'           Punctuation
+'\n                  ' Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'type'        Keyword
+' '           Text
+'type'        Keyword
+' '           Text
+'type'        Keyword
+' '           Text
+'low'         Name.Variable
+'\n       '   Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'test'        Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'>='          Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'test'        Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'>'           Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n             ' Text
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'error-of-type' Name.Variable
+' '           Text
+"'error"      Literal.String.Symbol
+'\n                  ' Text
+'#1#'         Operator
+' '           Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'type'        Keyword
+' '           Text
+'type'        Keyword
+' '           Text
+'type'        Keyword
+' '           Text
+'high'        Name.Variable
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'c-typep-number' Name.Variable
+' '           Text
+'('           Punctuation
+'caller'      Name.Variable
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+','           Operator
+'tester'      Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+','           Operator
+'low'         Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'<'           Name.Builtin
+' '           Text
+','           Operator
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'c-warn'      Name.Variable
+' '           Text
+'#1='         Operator
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: argument to ~S must be *, ~S or a list of ~S: ~S"' Literal.String
+')'           Punctuation
+'\n                           ' Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'caller'      Name.Variable
+' '           Text
+'caller'      Name.Variable
+' '           Text
+'caller'      Name.Variable
+' '           Text
+'low'         Name.Variable
+'\n                   ' Text
+')'           Punctuation
+'\n                   ' Text
+'('           Punctuation
+'throw'       Keyword
+' '           Text
+"'c-TYPEP"    Literal.String.Symbol
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'>='          Name.Builtin
+' '           Text
+','           Operator
+'high'        Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'>'           Name.Builtin
+' '           Text
+','           Operator
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'c-warn'      Name.Variable
+' '           Text
+'#1#'         Operator
+' '           Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'caller'      Name.Variable
+' '           Text
+'caller'      Name.Variable
+' '           Text
+'caller'      Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+'\n                   ' Text
+'('           Punctuation
+'throw'       Keyword
+' '           Text
+"'c-TYPEP"    Literal.String.Symbol
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+'     '       Text
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'ARRAY'       Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'ensure-rank' Name.Variable
+' '           Text
+'ARRAY'       Name.Variable
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'dim'         Name.Variable
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'ARRAY'       Name.Variable
+' '           Text
+'dim'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'arrayp'      Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'equal'       Name.Builtin
+' '           Text
+'('           Punctuation
+'array-element-type' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-rank'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'array-rank'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'every'       Name.Builtin
+' '           Text
+"#'"          Name.Function
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'a'           Name.Variable
+' '           Text
+'b'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'a'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'a'           Name.Variable
+' '           Text
+'b'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                         ' Text
+'dims'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimensions' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'   '         Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-array' Name.Variable
+' '           Text
+"'ARRAYP"     Literal.String.Symbol
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+'dims'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SIMPLE-ARRAY' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'ensure-rank' Name.Variable
+' '           Text
+'SIMPLE-ARRAY' Name.Variable
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'dim'         Name.Variable
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'SIMPLE-ARRAY' Name.Variable
+' '           Text
+'dim'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'simple-array-p' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'equal'       Name.Builtin
+' '           Text
+'('           Punctuation
+'array-element-type' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'dims'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-rank'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'dims'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'array-rank'  Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'every'       Name.Builtin
+' '           Text
+"#'"          Name.Function
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'a'           Name.Variable
+' '           Text
+'b'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'a'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'a'           Name.Variable
+' '           Text
+'b'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                         ' Text
+'dims'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimensions' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'   '         Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'    '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-array' Name.Variable
+' '           Text
+"'SIMPLE-ARRAY-P" Literal.String.Symbol
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+'dims'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'VECTOR'      Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'VECTOR'      Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'vectorp'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'equal'       Name.Builtin
+' '           Text
+'('           Punctuation
+'array-element-type' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+'VECTORP'     Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQUAL'       Name.Variable
+' '           Text
+'('           Punctuation
+'ARRAY-ELEMENT-TYPE' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"',"          Literal.String.Symbol
+'('           Punctuation
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+'('           Punctuation
+'ARRAY-DIMENSION' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+"',size"      Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SIMPLE-VECTOR' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'SIMLPE-VECTOR' Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'simple-vector-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'SIMPLE-VECTOR-P" Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'COMPLEX'     Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'rtype'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'itype'       Name.Variable
+' '           Text
+'rtype'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'complexp'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'rtype'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'('           Punctuation
+'realpart'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'upgraded-complex-part-type' Name.Builtin
+' '           Text
+'rtype'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'itype'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'('           Punctuation
+'imagpart'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'upgraded-complex-part-type' Name.Builtin
+' '           Text
+'itype'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+'COMPLEXP'    Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'rtype'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'TYPEP'       Name.Variable
+' '           Text
+'('           Punctuation
+'REALPART'    Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"',"          Literal.String.Symbol
+'('           Punctuation
+'upgraded-complex-part-type' Name.Builtin
+' '           Text
+'rtype'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'itype'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n            ' Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+'\n            ' Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'TYPEP'       Name.Variable
+' '           Text
+'('           Punctuation
+'IMAGPART'    Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"',"          Literal.String.Symbol
+'('           Punctuation
+'upgraded-complex-part-type' Name.Builtin
+' '           Text
+'itype'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'INTEGER'     Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'integerp'    Name.Builtin
+' '           Text
+"'INTEGER"    Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'INTEGER"    Literal.String.Symbol
+' '           Text
+"'INTEGERP"   Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'MOD'         Name.Variable
+' '           Text
+'('           Punctuation
+'n'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: argument to MOD must be an integer: ~S"' Literal.String
+')'           Punctuation
+'\n           ' Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'n'           Name.Variable
+'\n  '        Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'<'           Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+'INTEGERP'    Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'NOT'         Name.Variable
+' '           Text
+'('           Punctuation
+'MINUSP'      Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'<'           Name.Builtin
+' '           Text
+','           Operator
+'x'           Name.Variable
+' '           Text
+','           Operator
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SIGNED-BYTE' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: argument to SIGNED-BYTE must be an integer or * : ~S"' Literal.String
+')'           Punctuation
+'\n           ' Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'n'           Name.Variable
+'\n  '        Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'<'           Name.Builtin
+' '           Text
+'('           Punctuation
+'integer-length' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+'INTEGERP'    Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+' '           Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'<'           Name.Builtin
+' '           Text
+'('           Punctuation
+'INTEGER-LENGTH' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+','           Operator
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S: argument to UNSIGNED-BYTE must be an integer or * : ~S"' Literal.String
+')'           Punctuation
+'\n           ' Text
+"'typep"      Literal.String.Symbol
+' '           Text
+'n'           Name.Variable
+'\n  '        Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'minusp'      Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'('           Punctuation
+'integer-length' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+'INTEGERP'    Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'NOT'         Name.Variable
+' '           Text
+'('           Punctuation
+'MINUSP'      Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+' '           Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'('           Punctuation
+'INTEGER-LENGTH' Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+','           Operator
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'REAL'        Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'realp'       Name.Builtin
+' '           Text
+"'REAL"       Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'REAL"       Literal.String.Symbol
+' '           Text
+"'REALP"      Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'RATIONAL'    Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'rationalp'   Name.Builtin
+' '           Text
+"'RATIONAL"   Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'RATIONAL"   Literal.String.Symbol
+' '           Text
+"'RATIONALP"  Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'FLOAT'       Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'floatp'      Name.Builtin
+' '           Text
+"'FLOAT"      Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'FLOAT"      Literal.String.Symbol
+' '           Text
+"'FLOATP"     Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SHORT-FLOAT' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'short-float-p' Name.Variable
+' '           Text
+"'SHORT-FLOAT" Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'SHORT-FLOAT" Literal.String.Symbol
+' '           Text
+"'SHORT-FLOAT-P" Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SINGLE-FLOAT' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'single-float-p' Name.Variable
+' '           Text
+"'SINGLE-FLOAT" Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'SINGLE-FLOAT" Literal.String.Symbol
+' '           Text
+"'SINGLE-FLOAT-P" Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'DOUBLE-FLOAT' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'double-float-p' Name.Variable
+' '           Text
+"'DOUBLE-FLOAT" Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'DOUBLE-FLOAT" Literal.String.Symbol
+' '           Text
+"'DOUBLE-FLOAT-P" Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'LONG-FLOAT'  Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'typep-number-test' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+"#'"          Name.Function
+'long-float-p' Name.Variable
+' '           Text
+"'LONG-FLOAT" Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-number' Name.Variable
+' '           Text
+"'LONG-FLOAT" Literal.String.Symbol
+' '           Text
+"'LONG-FLOAT-P" Literal.String.Symbol
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'STRING'      Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'STRING'      Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'stringp'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'STRINGP"    Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SIMPLE-STRING' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'SIMPLE-STRING' Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'simple-string-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'SIMPLE-STRING-P" Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'BASE-STRING' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'BASE-STRING' Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'stringp'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'STRINGP"    Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SIMPLE-BASE-STRING' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'SIMPLE-BASE-STRING' Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'simple-string-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'SIMPLE-STRING-P" Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'BIT-VECTOR'  Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'BIT-VECTOR'  Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'bit-vector-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'BIT-VECTOR-P" Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'SIMPLE-BIT-VECTOR' Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'ensure-dim'  Name.Variable
+' '           Text
+'SIMPLE-BIT-VECTOR' Name.Variable
+' '           Text
+'size'        Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'simple-bit-vector-p' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'size'        Name.Variable
+' '           Text
+'('           Punctuation
+'array-dimension' Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'c-typep-vector' Name.Variable
+' '           Text
+"'SIMPLE-BIT-VECTOR-P" Literal.String.Symbol
+' '           Text
+'size'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'def-compound-type' Name.Variable
+' '           Text
+'CONS'        Name.Variable
+' '           Text
+'('           Punctuation
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'car-type'    Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'cdr-type'    Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'nil'         Name.Constant
+'\n  '        Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'car-type'    Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'car-type'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'cdr-type'    Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'cdr-type'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+')'           Punctuation
+'\n  '        Text
+'`'           Operator
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'('           Punctuation
+'CONSP'       Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'car-type'    Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+' '           Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'TYPEP'       Name.Variable
+' '           Text
+'('           Punctuation
+'CAR'         Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"',car-type"  Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+',@'          Operator
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'cdr-type'    Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+')'           Punctuation
+' '           Text
+'`'           Operator
+'('           Punctuation
+'('           Punctuation
+'TYPEP'       Name.Variable
+' '           Text
+'('           Punctuation
+'CDR'         Name.Variable
+' '           Text
+','           Operator
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"',cdr-type"  Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n   '       Text
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+'\n\n'        Text
+
+'('           Punctuation
+'fmakunbound' Name.Builtin
+' '           Text
+"'def-compound-type" Literal.String.Symbol
+')'           Punctuation
+'\n\n'        Text
+
+';; ----------------------------------------------------------------------------' Comment.Single
+'\n\n'        Text
+
+'; Typtest ohne Gefahr einer Fehlermeldung. Für SIGNAL und HANDLER-BIND.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'safe-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'y'           Name.Variable
+' '           Text
+'&optional'   Keyword
+' '           Text
+'env'         Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'*error-handler*' Name.Variable.Global
+'\n          ' Text
+"#'"          Name.Function
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'&rest'       Keyword
+' '           Text
+'error-args'  Name.Variable
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'declare'     Keyword
+' '           Text
+'('           Punctuation
+'ignore'      Keyword
+' '           Text
+'error-args'  Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'safe-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'nil'         Name.Constant
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n       '   Text
+')'           Punctuation
+')'           Punctuation
+'   '         Text
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+'y'           Name.Variable
+' '           Text
+'env'         Name.Variable
+')'           Punctuation
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n\n'        Text
+
+'; Umwandlung eines "type for declaration" in einen "type for discrimination".' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'type-for-discrimination' Name.Variable
+' '           Text
+'('           Punctuation
+'y'           Name.Variable
+' '           Text
+'&optional'   Keyword
+' '           Text
+'('           Punctuation
+'notp'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+' '           Text
+'&aux'        Keyword
+' '           Text
+'f'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'y'           Name.Variable
+' '           Text
+"'TYPE-SYMBOL" Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'y'           Name.Variable
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'y'           Name.Variable
+' '           Text
+"'DEFTYPE-EXPANDER" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'let*'        Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'z'           Name.Variable
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'list'        Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                         ' Text
+'('           Punctuation
+'zx'          Name.Variable
+' '           Text
+'('           Punctuation
+'type-for-discrimination' Name.Variable
+' '           Text
+'z'           Name.Variable
+' '           Text
+'notp'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'zx'          Name.Variable
+' '           Text
+'z'           Name.Variable
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+' '           Text
+'zx'          Name.Variable
+')'           Punctuation
+'\n                 ' Text
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'SATISFIES'   Name.Variable
+' '           Text
+'MEMBER'      Name.Variable
+' '           Text
+'EQL'         Name.Variable
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'NOT'         Name.Variable
+'\n              ' Text
+'('           Punctuation
+'let*'        Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'z'           Name.Variable
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'zx'          Name.Variable
+' '           Text
+'('           Punctuation
+'type-for-discrimination' Name.Variable
+' '           Text
+'z'           Name.Variable
+' '           Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'notp'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'zx'          Name.Variable
+' '           Text
+'z'           Name.Variable
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+' '           Text
+'`'           Operator
+'('           Punctuation
+'NOT'         Name.Variable
+' '           Text
+','           Operator
+'zx'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'OR'          Name.Variable
+' '           Text
+'COMPLEX'     Name.Variable
+' '           Text
+'VALUES'      Name.Variable
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'let*'        Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'z'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                     ' Text
+'('           Punctuation
+'zx'          Name.Variable
+' '           Text
+'('           Punctuation
+'mapcar'      Name.Builtin
+' '           Text
+"#'"          Name.Function
+'('           Punctuation
+'lambda'      Keyword
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'type-for-discrimination' Name.Variable
+' '           Text
+'x'           Name.Variable
+' '           Text
+'notp'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'z'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'every'       Name.Builtin
+' '           Text
+"#'"          Name.Function
+'eql'         Name.Builtin
+' '           Text
+'z'           Name.Variable
+' '           Text
+'zx'          Name.Variable
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+' '           Text
+'('           Punctuation
+'cons'        Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+'zx'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'FUNCTION'    Name.Variable
+'\n              ' Text
+';; (FUNCTION arg-types res-type) is somewhere between' Comment.Single
+'\n              ' Text
+';; NIL and FUNCTION, but undecidable.' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'notp'        Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+' '           Text
+"'FUNCTION"   Literal.String.Symbol
+')'           Punctuation
+'\n             ' Text
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'f'           Name.Variable
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+' '           Text
+"'DEFTYPE-EXPANDER" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                       ' Text
+'('           Punctuation
+'let*'        Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'z'           Name.Variable
+' '           Text
+'('           Punctuation
+'funcall'     Name.Builtin
+' '           Text
+'f'           Name.Variable
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                              ' Text
+'('           Punctuation
+'zx'          Name.Variable
+' '           Text
+'('           Punctuation
+'type-for-discrimination' Name.Variable
+' '           Text
+'z'           Name.Variable
+' '           Text
+'notp'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                         ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'zx'          Name.Variable
+' '           Text
+'z'           Name.Variable
+')'           Punctuation
+' '           Text
+'y'           Name.Variable
+' '           Text
+'zx'          Name.Variable
+')'           Punctuation
+'\n                      ' Text
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n        '  Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'  '          Text
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'y'           Name.Variable
+')'           Punctuation
+'\n'          Text
+
+')'           Punctuation
+' '           Text
+')'           Punctuation
+'\n\n'        Text
+
+'; Testet eine Liste von Werten auf Erfüllen eines Type-Specifiers. Für THE.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'; ABI'       Comment.Single
+'\n  '        Text
+'('           Punctuation
+'macrolet'    Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'near-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'objform'     Name.Variable
+' '           Text
+'typform'     Name.Variable
+')'           Punctuation
+'\n               ' Text
+';; near-typep ist wie typep, nur dass das Objekt auch ein' Comment.Single
+'\n               ' Text
+';; Read-Label sein darf. Das tritt z.B. auf bei' Comment.Single
+'\n               ' Text
+';; (read-from-string "#1=#S(FOO :X #1#)")' Comment.Single
+'\n               ' Text
+';; im Konstruktor MAKE-FOO. Die Implementation ist aber' Comment.Single
+'\n               ' Text
+';; nicht gezwungen, bei fehlerhaftem THE zwingend einen' Comment.Single
+'\n               ' Text
+';; Fehler zu melden, darum ist ein lascherer Typcheck hier' Comment.Single
+'\n               ' Text
+';; erlaubt.' Comment.Single
+'\n               ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'g'           Name.Variable
+' '           Text
+'('           Punctuation
+'gensym'      Name.Builtin
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+'`'           Operator
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+','           Operator
+'g'           Name.Variable
+' '           Text
+','           Operator
+'objform'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+','           Operator
+'g'           Name.Variable
+' '           Text
+','           Operator
+'typform'     Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'type-of'     Name.Builtin
+' '           Text
+','           Operator
+'g'           Name.Variable
+')'           Punctuation
+' '           Text
+"'READ-LABEL" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'VALUES"     Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n      '    Text
+';; The VALUES type specifier is ill-defined in ANSI CL.' Comment.Single
+'\n      '    Text
+';;'          Comment.Single
+'\n      '    Text
+';; There are two possibilities to define a VALUES type specifier in a' Comment.Single
+'\n      '    Text
+';; sane way:' Comment.Single
+'\n      '    Text
+';; - (EXACT-VALUES type1 ... [&optional ...]) describes the exact shape' Comment.Single
+'\n      '    Text
+';;   of the values list, as received by MULTIPLE-VALUE-LIST.' Comment.Single
+'\n      '    Text
+";;   For example, (EXACT-VALUES SYMBOL) is matched by (values 'a) but not" Comment.Single
+'\n      '    Text
+";;   by (values 'a 'b) or (values)." Comment.Single
+'\n      '    Text
+';; - (ASSIGNABLE-VALUES type1 ... [&optional ...]) describes the values' Comment.Single
+'\n      '    Text
+';;   as received by a set of variables through MULTIPLE-VALUE-BIND or' Comment.Single
+'\n      '    Text
+';;   MULTIPLE-VALUE-SETQ. For example, (ASSIGNABLE-VALUES SYMBOL) is' Comment.Single
+'\n      '    Text
+';;   defined by whether' Comment.Single
+'\n      '    Text
+';;     (MULTIPLE-VALUE-BIND (var1) values (DECLARE (TYPE SYMBOL var1)) ...)' Comment.Single
+'\n      '    Text
+';;   is valid or not; therefore (ASSIGNABLE-VALUES SYMBOL) is matched by' Comment.Single
+'\n      '    Text
+";;   (values 'a) and (values 'a 'b) and (values)." Comment.Single
+'\n      '    Text
+';;   Note that &OPTIONAL is actually redundant here:' Comment.Single
+'\n      '    Text
+';;     (ASSIGNABLE-VALUES type1 ... &optional otype1 ...)' Comment.Single
+'\n      '    Text
+';;   is equivalent to' Comment.Single
+'\n      '    Text
+';;     (ASSIGNABLE-VALUES type1 ... (OR NULL otype1) ...)' Comment.Single
+'\n      '    Text
+';; HyperSpec/Body/typspe_values.html indicates that VALUES means' Comment.Single
+'\n      '    Text
+';; EXACT-VALUES; however, HyperSpec/Body/speope_the.html indicates that' Comment.Single
+'\n      '    Text
+';; VALUES means ASSIGNABLE-VALUES.' Comment.Single
+'\n      '    Text
+';;'          Comment.Single
+'\n      '    Text
+';; SBCL interprets the VALUES type specifier to mean EXACT-VALUES when' Comment.Single
+'\n      '    Text
+';; it contains &OPTIONAL or &REST, but ASSIGNABLE-VALUES when it has' Comment.Single
+'\n      '    Text
+';; only a tuple of type specifiers. This is utter nonsense, in particular' Comment.Single
+'\n      '    Text
+';; because it makes (VALUES type1 ... typek &OPTIONAL)' Comment.Single
+'\n      '    Text
+';; different from   (VALUES type1 ... typek).' Comment.Single
+'\n      '    Text
+';;'          Comment.Single
+'\n      '    Text
+';; Here we use the ASSIGNABLE-VALUES interpretation.' Comment.Single
+'\n      '    Text
+";; In SUBTYPEP we just punt and don't assume any interpretation." Comment.Single
+'\n      '    Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'vals'        Name.Variable
+' '           Text
+'values'      Name.Builtin
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'types'       Name.Variable
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+';; required:' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'loop'        Name.Builtin
+'\n          ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'memq'        Name.Variable
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'lambda-list-keywords' Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'near-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+';; &optional:' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+"'&optional"  Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'types'       Name.Variable
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'loop'        Name.Builtin
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'memq'        Name.Variable
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'lambda-list-keywords' Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'near-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+';; &rest &key:' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'&rest'       Keyword
+'\n           ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'types'       Name.Variable
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'the"        Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'near-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'&key'        Keyword
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'the"        Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+"'&key"       Literal.String.Symbol
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'progn'       Keyword
+'\n            ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'types'       Name.Variable
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'oddp'        Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'keywords'    Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'loop'        Name.Builtin
+'\n                ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'vals'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'t'           Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'memq'        Name.Variable
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'lambda-list-keywords' Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'item'        Name.Variable
+' '           Text
+'('           Punctuation
+'pop'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'listp'       Name.Builtin
+' '           Text
+'item'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'item'        Name.Variable
+')'           Punctuation
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+'\n                               ' Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'item'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'the"        Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'kw'          Name.Variable
+' '           Text
+'('           Punctuation
+'symbol-to-keyword' Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'item'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'near-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'getf'        Name.Builtin
+' '           Text
+'vals'        Name.Variable
+' '           Text
+'kw'          Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'item'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'push'        Name.Builtin
+' '           Text
+'kw'          Name.Variable
+' '           Text
+'keywords'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+"'&allow-other-keys" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'types'       Name.Variable
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'getf'        Name.Builtin
+' '           Text
+'vals'        Name.Variable
+' '           Text
+"'"           Operator
+':allow-other-keys' Literal.String.Symbol
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'do'          Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'L'           Name.Variable
+' '           Text
+'vals'        Name.Variable
+' '           Text
+'('           Punctuation
+'cddr'        Name.Builtin
+' '           Text
+'L'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'('           Punctuation
+'atom'        Name.Builtin
+' '           Text
+'L'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'memq'        Name.Variable
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'L'           Name.Variable
+')'           Punctuation
+' '           Text
+'keywords'    Name.Variable
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'%the'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'types'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'the"        Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'t'           Name.Constant
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'near-typep'  Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'values'      Name.Builtin
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'values'      Name.Builtin
+')'           Punctuation
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+';;; ===========================================================================' Comment.Single
+'\n\n'        Text
+
+';; SUBTYPEP' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'load'        Name.Builtin
+' '           Text
+'"subtypep"'  Literal.String
+')'           Punctuation
+'\n\n\n'      Text
+
+';; Returns the number of bytes that are needed to represent #\\Null in a' Comment.Single
+'\n'          Text
+
+';; given encoding.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'encoding-zeroes' Name.Variable
+' '           Text
+'('           Punctuation
+'encoding'    Name.Variable
+')'           Punctuation
+'\n  '        Text
+'#+'          Operator
+'UNICODE'     Name.Variable
+'\n  '        Text
+';; this should use min_bytes_per_char for cache, not the hash table' Comment.Single
+'\n  '        Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'name'        Name.Variable
+' '           Text
+'('           Punctuation
+'ext:encoding-charset' Name.Variable
+' '           Text
+'encoding'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'table'       Name.Variable
+' '           Text
+'#.'          Operator
+'('           Punctuation
+'make-hash-table' Name.Builtin
+' '           Text
+':key-type'   Literal.String.Symbol
+' '           Text
+"'"           Operator
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'string'      Name.Builtin
+' '           Text
+'symbol'      Name.Class
+')'           Punctuation
+' '           Text
+':value-type' Literal.String.Symbol
+' '           Text
+"'fixnum"     Literal.String.Symbol
+'\n                                  ' Text
+':test'       Literal.String.Symbol
+' '           Text
+"'stablehash-equal" Literal.String.Symbol
+' '           Text
+':warn-if-needs-rehash-after-gc' Literal.String.Symbol
+' '           Text
+'t'           Name.Constant
+'\n                                  ' Text
+':initial-contents' Literal.String.Symbol
+' '           Text
+"'"           Operator
+'('           Punctuation
+'('           Punctuation
+'"UTF-7"'     Literal.String
+' '           Text
+'.'           Operator
+' '           Text
+'1'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'tester'      Name.Variable
+' '           Text
+'#.'          Operator
+'('           Punctuation
+'make-string' Name.Builtin
+' '           Text
+'2'           Literal.Number.Integer
+' '           Text
+':initial-element' Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'code-char'   Name.Builtin
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'gethash'     Name.Builtin
+' '           Text
+'name'        Name.Variable
+' '           Text
+'table'       Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'setf'        Name.Builtin
+' '           Text
+'('           Punctuation
+'gethash'     Name.Builtin
+' '           Text
+'name'        Name.Variable
+' '           Text
+'table'       Name.Variable
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'-'           Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'('           Punctuation
+'ext:convert-string-to-bytes' Name.Variable
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'encoding'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'('           Punctuation
+'ext:convert-string-to-bytes' Name.Variable
+' '           Text
+'tester'      Name.Variable
+' '           Text
+'encoding'    Name.Variable
+'\n                                                      ' Text
+':end'        Literal.String.Symbol
+' '           Text
+'1'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'#-'          Operator
+'UNICODE'     Name.Variable
+' '           Text
+'1'           Literal.Number.Integer
+')'           Punctuation
+'\n\n'        Text
+
+';; Determines two values low,high such that' Comment.Single
+'\n'          Text
+
+';;   (subtypep type `(INTEGER ,low ,high))' Comment.Single
+'\n'          Text
+
+';; holds and low is as large as possible and high is as small as possible.' Comment.Single
+'\n'          Text
+
+';; low = * means -infinity, high = * means infinity.' Comment.Single
+'\n'          Text
+
+";; When (subtypep type 'INTEGER) is false, the values NIL,NIL are returned." Comment.Single
+'\n'          Text
+
+';; We need this function only for MAKE-ARRAY, UPGRADED-ARRAY-ELEMENT-TYPE and' Comment.Single
+'\n'          Text
+
+';; OPEN and can therefore w.l.o.g. replace' Comment.Single
+'\n'          Text
+
+';;   type  with  `(OR ,type (MEMBER 0))' Comment.Single
+'\n'          Text
+
+'#|'          Comment.Multiline
+" ;; The original implementation calls canonicalize-type and then applies\n   ;; a particular SUBTYPE variant:\n (defun subtype-integer (type)\n  (macrolet ((yes () '(return-from subtype-integer (values low high)))\n             (no () '(return-from subtype-integer nil))\n             (unknown () '(return-from subtype-integer nil)))\n    (setq type (canonicalize-type type))\n    (if (consp type)\n      (case (first type)\n        (MEMBER ; (MEMBER &rest objects)\n          ;; All elements must be of type INTEGER.\n          (let ((low 0) (high 0)) ; wlog!\n            (dolist (x (rest type) (yes))\n              (unless (typep x 'INTEGER) (return (no)))\n              (setq low (min low x) high (max high x)))))\n        (OR ; (OR type*)\n          ;; Every type must be subtype of INTEGER.\n          (let ((low 0) (high 0)) ; wlog!\n            (dolist (type1 (rest type) (yes))\n              (multiple-value-bind (low1 high1) (subtype-integer type1)\n                (unless low1 (return (no)))\n                (setq low (if (or (eq low '*) (eq low1 '*)) '* (min low low1))\n                      high (if (or (eq high '*) (eq high1 '*))\n                               '* (max high high1)))))))\n        (AND ; (AND type*)\n          ;; If one of the types is subtype of INTEGER, then yes,\n          ;; otherwise unknown.\n          (let ((low nil) (high nil))\n            (dolist (type1 (rest type))\n              (multiple-value-bind (low1 high1) (subtype-integer type1)\n                (when low1\n                  (if low\n                    (setq low (if (eq low '*) low1 (if (eq low1 '*) low (max low low1)))\n                          high (if (eq high '*) high1 (if (eq high1 '*) high (min high high1))))\n                    (setq low low1 high high1)))))\n            (if low\n              (progn\n                (when (and (numberp low) (numberp high) (not (<= low high)))\n                  (setq low 0 high 0) ; type equivalent to NIL)\n                (yes))\n              (unknown)))))\n      (setq type (list type)))\n    (if (eq (first type) 'INTEGER)\n      (let ((low (if (rest type) (second type) '*))\n            (high (if (cddr type) (third type) '*)))\n        (when (consp low)\n          (setq low (first low))\n          (when (numberp low) (incf low)))\n        (when (consp high)\n          (setq high (first high))\n          (when (numberp high) (decf high)))\n        (when (and (numberp low) (numberp high) (not (<= low high))) ; type leer?\n          (setq low 0 high 0))\n        (yes))\n      (if (and (eq (first type) 'INTERVALS) (eq (second type) 'INTEGER))\n        (let ((low (third type))\n              (high (car (last type))))\n          (when (consp low)\n            (setq low (first low))\n            (when (numberp low) (incf low)))\n          (when (consp high)\n            (setq high (first high))\n            (when (numberp high) (decf high)))\n          (yes))\n        (unknown)))))\n" Comment.Multiline
+
+'|#'          Comment.Multiline
+' '           Text
+';; This implementation inlines the (tail-recursive) canonicalize-type' Comment.Single
+'\n   '       Text
+";; function. Its advantage is that it doesn't cons as much." Comment.Single
+'\n   '       Text
+";; (For example, (subtype-integer '(UNSIGNED-BYTE 8)) doesn't cons.)" Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'subtype-integer' Name.Variable
+' '           Text
+'('           Punctuation
+'type'        Keyword
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'macrolet'    Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'yes'         Name.Variable
+' '           Text
+'('           Punctuation
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'subtype-integer' Name.Variable
+' '           Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'no'          Name.Variable
+' '           Text
+'('           Punctuation
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'subtype-integer' Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'unknown'     Name.Variable
+' '           Text
+'('           Punctuation
+')'           Punctuation
+' '           Text
+"'"           Operator
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'subtype-integer' Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'type'        Keyword
+' '           Text
+'('           Punctuation
+'expand-deftype' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'type'        Keyword
+'\n             ' Text
+'('           Punctuation
+'BIT'         Name.Variable
+' '           Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'1'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'FIXNUM'      Name.Variable
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'"           Operator
+'#,'          Operator
+'most-negative-fixnum' Name.Variable
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'"           Operator
+'#,'          Operator
+'most-positive-fixnum' Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'INTEGER'     Name.Variable
+' '           Text
+'BIGNUM'      Name.Variable
+' '           Text
+'SIGNED-BYTE' Name.Variable
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'('           Punctuation
+'NIL'         Name.Constant
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; wlog!'     Comment.Single
+'\n             ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'list-length' Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'('           Punctuation
+'last'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'MEMBER'      Name.Variable
+' '           Text
+'; (MEMBER &rest objects)' Comment.Single
+'\n              ' Text
+';; All elements must be of type INTEGER.' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; wlog!'     Comment.Single
+'\n                ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+"'INTEGER"    Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+' '           Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'min'         Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'max'         Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+'; (EQL object)' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+"'INTEGER"    Literal.String.Symbol
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'min'         Name.Builtin
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'max'         Name.Builtin
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'OR'          Name.Variable
+' '           Text
+'; (OR type*)' Comment.Single
+'\n              ' Text
+';; Every type must be subtype of INTEGER.' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; wlog!'     Comment.Single
+'\n                ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'type1'       Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'multiple-value-bind' Name.Builtin
+' '           Text
+'('           Punctuation
+'low1'        Name.Variable
+' '           Text
+'high1'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'subtype-integer' Name.Variable
+' '           Text
+'type1'       Name.Variable
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'low1'        Name.Variable
+' '           Text
+'('           Punctuation
+'return'      Name.Builtin
+' '           Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'low1'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                                  ' Text
+"'*"          Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'min'         Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'low1'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                          ' Text
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'high1'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                                   ' Text
+"'*"          Literal.String.Symbol
+' '           Text
+'('           Punctuation
+'max'         Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+'high1'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'; (AND type*)' Comment.Single
+'\n              ' Text
+';; If one of the types is subtype of INTEGER, then yes,' Comment.Single
+'\n              ' Text
+';; otherwise unknown.' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'type1'       Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'multiple-value-bind' Name.Builtin
+' '           Text
+'('           Punctuation
+'low1'        Name.Variable
+' '           Text
+'high1'       Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'subtype-integer' Name.Variable
+' '           Text
+'type1'       Name.Variable
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'low1'        Name.Variable
+'\n                      ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'low'         Name.Variable
+'\n                        ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'low1'        Name.Variable
+'\n                                      ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'low1'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'low'         Name.Variable
+'\n                                          ' Text
+'('           Punctuation
+'max'         Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'low1'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                              ' Text
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'high1'       Name.Variable
+'\n                                       ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'high1'       Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'high'        Name.Variable
+'\n                                           ' Text
+'('           Punctuation
+'min'         Name.Builtin
+' '           Text
+'high'        Name.Variable
+' '           Text
+'high1'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'low1'        Name.Variable
+'\n                              ' Text
+'high'        Name.Variable
+' '           Text
+'high1'       Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'low'         Name.Variable
+'\n                  ' Text
+'('           Punctuation
+'progn'       Keyword
+'\n                    ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+'\n                               ' Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'high'        Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; type equivalent to NIL' Comment.Single
+'\n                    ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'unknown'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'INTEGER'     Name.Variable
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'cddr'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'third'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'incf'        Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'decf'        Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'not'         Name.Builtin
+' '           Text
+'('           Punctuation
+'<='          Name.Builtin
+' '           Text
+'low'         Name.Variable
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'high'        Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; type equivalent to NIL' Comment.Single
+'\n                ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'INTERVALS'   Name.Variable
+'\n              ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'INTEGER"    Literal.String.Symbol
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'third'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'car'         Name.Builtin
+' '           Text
+'('           Punctuation
+'last'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'incf'        Name.Builtin
+' '           Text
+'low'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'numberp'     Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'decf'        Name.Builtin
+' '           Text
+'high'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'unknown'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'MOD'         Name.Variable
+' '           Text
+'; (MOD n)'   Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'n'           Name.Variable
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'>='          Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'n'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'1-'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'SIGNED-BYTE' Name.Variable
+' '           Text
+'; (SIGNED-BYTE &optional s)' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'s'           Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'s'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'progn'       Keyword
+'\n                    ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'s'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'plusp'       Name.Builtin
+' '           Text
+'s'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'n'           Name.Variable
+' '           Text
+'('           Punctuation
+'ash'         Name.Builtin
+' '           Text
+'1'           Literal.Number.Integer
+' '           Text
+'('           Punctuation
+'1-'          Name.Builtin
+' '           Text
+'s'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; (ash 1 *) == (expt 2 *)' Comment.Single
+'\n                      ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'-'           Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'1-'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'UNSIGNED-BYTE' Name.Variable
+' '           Text
+'; (UNSIGNED-BYTE &optional s)' Comment.Single
+'\n              ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'s'           Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'s'           Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'progn'       Keyword
+'\n                      ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'integerp'    Name.Builtin
+' '           Text
+'s'           Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'>='          Name.Builtin
+' '           Text
+'s'           Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                      ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'n'           Name.Variable
+' '           Text
+'('           Punctuation
+'ash'         Name.Builtin
+' '           Text
+'1'           Literal.Number.Integer
+' '           Text
+'s'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'; (ash 1 *) == (expt 2 *)' Comment.Single
+'\n                        ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'1-'          Name.Builtin
+' '           Text
+'n'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                          ' Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'('           Punctuation
+'clos::defined-class-p' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'clos::built-in-class-p' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'('           Punctuation
+'clos:class-name' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'CLOS::CLOSCLASS" Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'return-from' Keyword
+' '           Text
+'subtype-integer' Name.Variable
+'\n               ' Text
+'('           Punctuation
+'subtype-integer' Name.Variable
+' '           Text
+'('           Punctuation
+'clos:class-name' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'('           Punctuation
+'clos::eql-specializer-p' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'clos::eql-specializer-singleton' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'typep'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+' '           Text
+"'INTEGER"    Literal.String.Symbol
+')'           Punctuation
+'\n               ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'low'         Name.Variable
+' '           Text
+'('           Punctuation
+'min'         Name.Builtin
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'high'        Name.Variable
+' '           Text
+'('           Punctuation
+'max'         Name.Builtin
+' '           Text
+'0'           Literal.Number.Integer
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'yes'         Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n               ' Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'('           Punctuation
+'encodingp'   Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'no'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n          ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+'#|'          Comment.Multiline
+" TODO: Fix subtype-integer such that this works.\nHenry Baker:\n (defun type-null (x)\n  (values (and (eq 'bit (upgraded-array-element-type `(or bit ,x)))\n               (not (typep 0 x))\n               (not (typep 1 x)))\n          t))\n (type-null '(and symbol number))\n (type-null '(and integer symbol))\n (type-null '(and integer character))\n" Comment.Multiline
+
+'|#'          Comment.Multiline
+'\n\n'        Text
+
+';; Determines a sequence kind (an atom, as defined in defseq.lisp: one of' Comment.Single
+'\n'          Text
+
+';;   LIST - stands for LIST' Comment.Single
+'\n'          Text
+
+';;   VECTOR - stands for (VECTOR T)' Comment.Single
+'\n'          Text
+
+';;   STRING - stands for (VECTOR CHARACTER)' Comment.Single
+'\n'          Text
+
+';;   1, 2, 4, 8, 16, 32 - stands for (VECTOR (UNSIGNED-BYTE n))' Comment.Single
+'\n'          Text
+
+';;   0 - stands for (VECTOR NIL))' Comment.Single
+'\n'          Text
+
+';; that indicates the sequence type meant by the given type. Other possible' Comment.Single
+'\n'          Text
+
+';; return values are' Comment.Single
+'\n'          Text
+
+';;   SEQUENCE - denoting a type whose intersection with (OR LIST VECTOR) is not' Comment.Single
+'\n'          Text
+
+';;              subtype of LIST or VECTOR, or' Comment.Single
+'\n'          Text
+
+';;   NIL - indicating a type whose intersection with (OR LIST VECTOR) is empty.' Comment.Single
+'\n'          Text
+
+';; When the type is (OR (VECTOR eltype1) ... (VECTOR eltypeN)), the chosen' Comment.Single
+'\n'          Text
+
+';; element type is the smallest element type that contains all of eltype1 ...' Comment.Single
+'\n'          Text
+
+';; eltypeN.' Comment.Single
+'\n'          Text
+
+';;'          Comment.Single
+'\n'          Text
+
+';; User-defined sequence types are not supported here.' Comment.Single
+'\n'          Text
+
+';;'          Comment.Single
+'\n'          Text
+
+';; This implementation inlines the (tail-recursive) canonicalize-type' Comment.Single
+'\n'          Text
+
+";; function. Its advantage is that it doesn't cons as much. Also it employs" Comment.Single
+'\n'          Text
+
+';; some heuristics and does not have the full power of SUBTYPEP.' Comment.Single
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'subtype-sequence' Name.Variable
+' '           Text
+'('           Punctuation
+'type'        Keyword
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'type'        Keyword
+' '           Text
+'('           Punctuation
+'expand-deftype' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'type'        Keyword
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'LIST'        Name.Variable
+' '           Text
+'CONS'        Name.Variable
+' '           Text
+'NULL'        Name.Variable
+')'           Punctuation
+' '           Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'NIL'         Name.Constant
+')'           Punctuation
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'BIT-VECTOR'  Name.Variable
+' '           Text
+'SIMPLE-BIT-VECTOR' Name.Variable
+')'           Punctuation
+' '           Text
+"'1"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'STRING'      Name.Variable
+' '           Text
+'SIMPLE-STRING' Name.Variable
+' '           Text
+'BASE-STRING' Name.Variable
+' '           Text
+'SIMPLE-BASE-STRING' Name.Variable
+')'           Punctuation
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'VECTOR'      Name.Variable
+' '           Text
+'SIMPLE-VECTOR' Name.Variable
+' '           Text
+'ARRAY'       Name.Variable
+' '           Text
+'SIMPLE-ARRAY' Name.Variable
+')'           Punctuation
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'SEQUENCE'    Name.Variable
+')'           Punctuation
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'list-length' Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'null'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'('           Punctuation
+'last'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'MEMBER'      Name.Variable
+' '           Text
+'; (MEMBER &rest objects)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'kind'        Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'kind'        Name.Variable
+' '           Text
+'('           Punctuation
+'sequence-type-union' Name.Variable
+' '           Text
+'kind'        Name.Variable
+' '           Text
+'('           Punctuation
+'type-of-sequence' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'kind'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'EQL'         Name.Variable
+' '           Text
+'; (EQL object)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'('           Punctuation
+'length'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'2'           Literal.Number.Integer
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'type-of-sequence' Name.Variable
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'OR'          Name.Variable
+' '           Text
+'; (OR type*)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'kind'        Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'kind'        Name.Variable
+' '           Text
+'('           Punctuation
+'sequence-type-union' Name.Variable
+' '           Text
+'kind'        Name.Variable
+' '           Text
+'('           Punctuation
+'subtype-sequence' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'kind'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'AND'         Name.Variable
+' '           Text
+'; (AND type*)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'kind'        Name.Variable
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'dolist'      Name.Builtin
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+' '           Text
+'('           Punctuation
+'rest'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n                ' Text
+'('           Punctuation
+'setq'        Keyword
+' '           Text
+'kind'        Name.Variable
+' '           Text
+'('           Punctuation
+'sequence-type-intersection' Name.Variable
+' '           Text
+'kind'        Name.Variable
+' '           Text
+'('           Punctuation
+'subtype-sequence' Name.Variable
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'kind'        Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'SIMPLE-BIT-VECTOR' Name.Variable
+' '           Text
+'BIT-VECTOR'  Name.Variable
+')'           Punctuation
+' '           Text
+'; (SIMPLE-BIT-VECTOR &optional size)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cddr'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+"'1"          Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'SIMPLE-STRING' Name.Variable
+' '           Text
+'STRING'      Name.Variable
+' '           Text
+'SIMPLE-BASE-STRING' Name.Variable
+' '           Text
+'BASE-STRING' Name.Variable
+')'           Punctuation
+' '           Text
+'; (SIMPLE-STRING &optional size)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cddr'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'SIMPLE-VECTOR' Name.Variable
+' '           Text
+'; (SIMPLE-VECTOR &optional size)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cddr'        Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'VECTOR'      Name.Variable
+' '           Text
+'ARRAY'       Name.Variable
+' '           Text
+'SIMPLE-ARRAY' Name.Variable
+')'           Punctuation
+' '           Text
+'; (VECTOR &optional el-type size), (ARRAY &optional el-type dimensions)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cdddr'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'el-type'     Name.Variable
+' '           Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'cdr'         Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+' '           Text
+"'*"          Literal.String.Symbol
+')'           Punctuation
+'\n                ' Text
+"'VECTOR"     Literal.String.Symbol
+'\n                ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eltype'      Name.Variable
+' '           Text
+'('           Punctuation
+'upgraded-array-element-type' Name.Builtin
+' '           Text
+'el-type'     Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'T"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'CHARACTER"  Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'BIT"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'1"          Literal.String.Symbol
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+' '           Text
+"'UNSIGNED-BYTE" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'0"          Literal.String.Symbol
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S is not up-to-date with ~S for element type ~S"' Literal.String
+')'           Punctuation
+'\n                                  ' Text
+"'subtypep-sequence" Literal.String.Symbol
+' '           Text
+"'upgraded-array-element-type" Literal.String.Symbol
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'('           Punctuation
+'CONS'        Name.Variable
+')'           Punctuation
+' '           Text
+'; (CONS &optional cartype cdrtype)' Comment.Single
+'\n            ' Text
+'('           Punctuation
+'when'        Name.Builtin
+' '           Text
+'('           Punctuation
+'cdddr'       Name.Builtin
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n              ' Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'subtypep"   Literal.String.Symbol
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'clos::defined-class-p' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'clos::built-in-class-p' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n                  ' Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'('           Punctuation
+'clos:class-name' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+' '           Text
+"'CLOS::CLOSCLASS" Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'subtype-sequence' Name.Variable
+' '           Text
+'('           Punctuation
+'clos:class-name' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'clos::eql-specializer-p' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'type-of-sequence' Name.Variable
+' '           Text
+'('           Punctuation
+'clos::eql-specializer-singleton' Name.Variable
+' '           Text
+'type'        Keyword
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'type-of-sequence' Name.Variable
+' '           Text
+'('           Punctuation
+'x'           Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'listp'       Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+' '           Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'vectorp'     Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+'\n         ' Text
+'('           Punctuation
+'let'         Keyword
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eltype'      Name.Variable
+' '           Text
+'('           Punctuation
+'array-element-type' Name.Builtin
+' '           Text
+'x'           Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n           ' Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'T"          Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'CHARACTER"  Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'BIT"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'1"          Literal.String.Symbol
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+' '           Text
+"'UNSIGNED-BYTE" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'second'      Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'eltype'      Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+"'0"          Literal.String.Symbol
+')'           Punctuation
+'\n                 ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'error'       Name.Builtin
+' '           Text
+'('           Punctuation
+'TEXT'        Name.Variable
+' '           Text
+'"~S is not up-to-date with ~S for element type ~S"' Literal.String
+')'           Punctuation
+'\n                           ' Text
+"'type-of-sequence" Literal.String.Symbol
+' '           Text
+"'array-element-type" Literal.String.Symbol
+' '           Text
+'eltype'      Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'sequence-type-union' Name.Variable
+' '           Text
+'('           Punctuation
+'t1'          Name.Variable
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'; Simple general rules.' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+' '           Text
+'t1'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'t1'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'; Now the union of two different types.' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'; union of LIST and a vector type' Comment.Single
+'\n         ' Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'t1'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'; union of STRING and an integer-vector type' Comment.Single
+'\n         ' Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'max'         Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n'          Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'sequence-type-intersection' Name.Variable
+' '           Text
+'('           Punctuation
+'t1'          Name.Variable
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'; Simple general rules.' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+' '           Text
+'t1'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+' '           Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'; Now the intersection of two different types.' Comment.Single
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'SEQUENCE"   Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'t1'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'LIST"       Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'; intersection of LIST and a vector type' Comment.Single
+'\n         ' Text
+"'NIL"        Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'VECTOR"     Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'t1'          Name.Variable
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eql'         Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+'0'           Literal.Number.Integer
+')'           Punctuation
+')'           Punctuation
+' '           Text
+"'0"          Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'eq'          Name.Builtin
+' '           Text
+'t2'          Name.Variable
+' '           Text
+"'STRING"     Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n         ' Text
+'; intersection of STRING and an integer-vector type' Comment.Single
+'\n         ' Text
+"'0"          Literal.String.Symbol
+')'           Punctuation
+'\n        '  Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'min'         Name.Builtin
+' '           Text
+'t1'          Name.Variable
+' '           Text
+'t2'          Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+';; ============================================================================' Comment.Single
+'\n\n'        Text
+
+'('           Punctuation
+'defun'       Name.Builtin
+' '           Text
+'type-expand' Name.Variable
+' '           Text
+'('           Punctuation
+'typespec'    Name.Variable
+' '           Text
+'&optional'   Keyword
+' '           Text
+'once-p'      Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'multiple-value-bind' Name.Builtin
+' '           Text
+'('           Punctuation
+'expanded'    Name.Variable
+' '           Text
+'user-defined-p' Name.Variable
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'expand-deftype' Name.Variable
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+'once-p'      Name.Variable
+')'           Punctuation
+'\n    '      Text
+'('           Punctuation
+'if'          Keyword
+' '           Text
+'user-defined-p' Name.Variable
+' '           Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'expanded'    Name.Variable
+' '           Text
+'user-defined-p' Name.Variable
+')'           Punctuation
+'\n      '    Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+"'TYPE-SYMBOL" Literal.String.Symbol
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n                   ' Text
+'('           Punctuation
+'('           Punctuation
+'or'          Name.Builtin
+' '           Text
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+"'DEFSTRUCT-DESCRIPTION" Literal.String.Symbol
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'clos-class'  Name.Variable
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+'\n                    ' Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n                   ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'type-expand" Literal.String.Symbol
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'('           Punctuation
+'and'         Name.Builtin
+' '           Text
+'('           Punctuation
+'consp'       Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'symbolp'     Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n             ' Text
+'('           Punctuation
+'case'        Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+'\n               ' Text
+'('           Punctuation
+'('           Punctuation
+'SATISFIES'   Name.Variable
+' '           Text
+'MEMBER'      Name.Variable
+' '           Text
+'EQL'         Name.Variable
+' '           Text
+'NOT'         Name.Variable
+' '           Text
+'AND'         Name.Variable
+' '           Text
+'OR'          Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n               ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'cond'        Name.Builtin
+' '           Text
+'('           Punctuation
+'('           Punctuation
+'get'         Name.Builtin
+' '           Text
+'('           Punctuation
+'first'       Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+' '           Text
+"'TYPE-LIST"  Literal.String.Symbol
+')'           Punctuation
+'\n                         ' Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n                        ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'type-expand" Literal.String.Symbol
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'('           Punctuation
+'clos::defined-class-p' Name.Variable
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+' '           Text
+'('           Punctuation
+'values'      Name.Builtin
+' '           Text
+'typespec'    Name.Variable
+' '           Text
+'nil'         Name.Constant
+')'           Punctuation
+')'           Punctuation
+'\n            ' Text
+'('           Punctuation
+'t'           Name.Constant
+' '           Text
+'('           Punctuation
+'typespec-error' Name.Variable
+' '           Text
+"'type-expand" Literal.String.Symbol
+' '           Text
+'typespec'    Name.Variable
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+')'           Punctuation
+'\n\n'        Text
+
+';; ============================================================================' Comment.Single
+'\n\n'        Text
+
+'('           Punctuation
+'unless'      Name.Builtin
+' '           Text
+'('           Punctuation
+'clos::funcallable-instance-p' Name.Variable
+' '           Text
+"#'"          Name.Function
+'clos::class-name' Name.Variable
+')'           Punctuation
+'\n  '        Text
+'('           Punctuation
+'fmakunbound' Name.Builtin
+' '           Text
+"'clos::class-name" Literal.String.Symbol
+')'           Punctuation
+')'           Punctuation
+'\n\n\n'      Text
+
+'('           Punctuation
+'keywordp'    Name.Builtin
+' '           Text
+':junk'       Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'T'           Name.Constant
+'\n\n'        Text
+
+'('           Punctuation
+'keywordp'    Name.Builtin
+' '           Text
+'::junk'      Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'T'           Name.Constant
+'\n\n'        Text
+
+'('           Punctuation
+'symbol-name' Name.Builtin
+' '           Text
+'::junk'      Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'"JUNK"'      Literal.String
+'\n\n'        Text
+
+'('           Punctuation
+'symbol-name' Name.Builtin
+' '           Text
+':#junk'      Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'"#JUNK"'     Literal.String
+'\n\n'        Text
+
+'('           Punctuation
+'symbol-name' Name.Builtin
+' '           Text
+':#.junk'     Literal.String.Symbol
+')'           Punctuation
+'\n  '        Text
+'"#.JUNK"'    Literal.String
+'\n'          Text