Description: <short summary of the patch>
 TODO: Put a short summary on the line above and replace this paragraph
 with a longer explanation of this change. Complete the meta-information
 with other relevant fields (see below for details). To make it easier, the
 information below has been extracted from the changelog. Adjust it or drop
 it.
 .
 gcl27 (2.7.0-26) unstable; urgency=medium
 .
   * Version_2_7_0pre29
Author: Camm Maguire <camm@debian.org>

---
The information above should follow the Patch Tagging Guidelines, please
checkout https://dep.debian.net/deps/dep3/ to learn about the format. Here
are templates for supplementary fields that you might want to add:

Origin: (upstream|backport|vendor|other), (<patch-url>|commit:<commit-id>)
Bug: <upstream-bugtracker-url>
Bug-Debian: https://bugs.debian.org/<bugnumber>
Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
Forwarded: (no|not-needed|<patch-forwarded-url>)
Applied-Upstream: <version>, (<commit-url>|commit:<commid-id>)
Reviewed-By: <name and email of someone who approved/reviewed the patch>
Last-Update: 2024-11-23

--- gcl27-2.7.0.orig/ansi-tests/log.lsp
+++ gcl27-2.7.0/ansi-tests/log.lsp
@@ -105,6 +105,14 @@
 	 collect (list x1 x2 rlist)))
   nil)
 
+(deftest log.9
+    (log (expt 2 1024))
+  709.782712893384)
+
+(deftest log.10
+    (log (complex (expt 2 1024) 3))
+  #C(709.782712893384 1.668805393880401E-308))
+
 ;;; FIXME
 ;;; Add tests for two-arg calls
 	 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpcall.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpcall.lsp
@@ -326,7 +326,7 @@
 
 (defun mod-argstr (n call st nsup)
   (let* ((x (commasep (append (nobs nsup "#") (nobs (- n nsup)) (when st (list "_l")))))
-	 (s (or (search "#" call) (length call))))
+	 (s (or (position #\# call) (length call))))
     (ms (subseq call 0 s) x)))
 
 (defun nvfun-wrap (cname argstr sig clp ap)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpenv.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpenv.lsp
@@ -803,9 +803,11 @@
     (c2expr body)))
 
 (defun check-vdecl (vnames ts is)
-  (dolist (x ts)
-    (unless (member (car x) vnames)
-      (cmpwarn "Type declaration was found for not bound variable ~s" (car x))))
+  (dolist (d ts)
+    (unless (member (car d) vnames);FIXME check error without this
+      (keyed-cmpnote (list 'free-type-declaration (car d))
+		     "free type declaration ~s ~s" (car d) (cdr d))
+      (c1infer-tp (list (car d) (cdr d)))))
   (dolist (x is)
     (unless (or (eq x 'ignorable) (member x vnames))
       (cmpwarn "Ignore/ignorable declaration was found for not bound variable ~s." x))))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpeval.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpeval.lsp
@@ -665,7 +665,7 @@
   (list 'comment (make-info :type t  :flags (iflags side-effects))
 	(with-output-to-string (s) (princ (car args) s))))
 (defun c2comment (comment)
-  (wt-nl "/*" comment "*/"))
+  (wt-nl "/*" (mysub (mysub comment "/*" "_*") "*/" "*_") "*/"))
 (si::putprop 'comment 'c1comment 'c1)
 (si::putprop 'comment 'c2comment 'c2)
 
@@ -680,7 +680,7 @@
 
 (defvar *annotate* nil)
 
-(defun c2inline (comment expr &aux (comment (mysub (mysub (write-to-string comment) "/*" "") "*/" "")))
+(defun c2inline (comment expr &aux (comment (mysub (mysub (write-to-string comment :length 3 :level 3) "/*" "") "*/" "")))
   (when *annotate* (wt-nl "/*")(princ comment *compiler-output1*)(wt "*/"))
   (c2expr expr)
   (when *annotate* (wt-nl "/* END ")(princ comment *compiler-output1*)(wt "*/")))
@@ -1414,7 +1414,7 @@
 ;	  ((< (cons-count src) 30))
 	  ((not (symbolp fun)))
 	  ((let* ((n (symbol-package fun))(n (when n (package-name n)))(p (find-package :lib))) 
-	     (when n (or (when p (find-symbol n p)) (string-equal "S" n)))));FIXME
+	     (when n (or (when p (find-symbol n p)) (string-equal "CSTRUCT" n)))));FIXME
 	  ((local-fun-p fun))
 	  ((intersection-p '(&key &rest) (cadr src)))
 	  ((member-if-not (lambda (x) (type>= (car x) (cdr x))) 
@@ -2096,14 +2096,10 @@
 ;;     res))
 
 (defun local-fun-p (fname)
-  (car (member-if (lambda (x) (when (fun-p x)
-				(or (eq fname x) (eq fname (fun-fn x))
-				    (when (eq fname (fun-name x)) (not (member x *lexical-env-mask*))))))
-		  *funs*)))
-
-(defun local-fun-call (id)
-  (let* ((fun (local-fun-p id)))
-    (when fun (fun-call fun))))
+  (typecase fname
+    (function (fn-get fname 'fun))
+    (fun fname)
+    (symbol (car (member-if (lambda (x) (when (fun-p x) (when (eq fname (fun-name x)) (not (member x *lexical-env-mask*))))) *funs*)))))
 
 (defun cmp-expand-macro-w (fd x)
   (macroexpand-helper
@@ -2131,10 +2127,6 @@
 	  (funcall fd args))
 	 ((and (setq fd (get fname 'c1g)) (inline-possible fname))
 	  (funcall fd fname args))
-	 ((and (setq fd (get fname 'c1conditional))
-	       (inline-possible fname)
-	       (funcall (car fd) args))
-	  (funcall (cdr fd) args))
 	 ((setq fd (macro-function fname))
 	  (c1expr (cmp-expand-macro-w fd whole)))
 	 ((eq fname 'si:|#,|)
@@ -2142,14 +2134,6 @@
 	 ((mi1 fname args)))))
 
 
-(defun replace-constant (lis &aux found tem)
-  (do ((v lis (cdr v)))
-      ((null v)  found)
-      (cond ((and (constantp (car v))
-		  (or (numberp (setq tem(eval (car v))))
-		      (characterp tem)))
-	     (setq found t) (setf (car v) tem)))))
-
 ;; (defun remove-doc-string (body)
 ;;   (nconc (do (d doc) ((or (not body) (if (stringp (car body)) 
 ;; 					 (or (endp (cdr body)) doc)
@@ -2783,7 +2767,7 @@
 
 
 (define-compiler-macro vector-push-extend (&whole form &rest args)
-  (let* ((vref (when (symbolp (cadr args)) (c1vref (cadr args))))
+  (let* ((vref (when (symbolp (cadr args)) (c1vref (cadr args))));FIXME local-aliases
 	 (var (car vref)))
     (when vref
       (do-setq-tp var form (reduce (lambda (y x) (if (type-and y x) (type-or1 y x) y))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpflet.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpflet.lsp
@@ -227,7 +227,7 @@
   
   (let ((*funs* (if labels *funs* ofuns)))
 ;    (mapc (lambda (x &aux (x (car x))) (setf (fun-fn x) (afe (cons 'df (current-env)) (mf (fun-name x))))) defs1))
-    (mapc (lambda (x &aux (x (car x))) (setf (fun-fn x) (mf (fun-name x)))) defs1))
+    (mapc (lambda (x &aux (x (car x))) (setf (fun-fn x) (mf (fun-name x) x))) defs1))
 
   (multiple-value-setq (body ss ts is other-decl) (c1body (cdr args) t))
   
@@ -253,125 +253,7 @@
 	 (cls (mapcar (lambda (x) (caddr (fun-c1cb x))) (remove-if-not 'fun-ref-ccb funs))))
     (if (or fns cls)
 	(list (if labels 'labels 'flet) info fns cls body)
-      body)))
-
-;; (defun c1flet-labels (labels args &aux body ss ts is other-decl (info (make-info))
-;; 			     defs1 fnames (ofuns *funs*) (*funs* *funs*))
-
-;;   (when (endp args) (too-few-args 'flet 1 0))
-
-;;   (dolist (def (car args) (setq defs1 (nreverse defs1)))
-;;     (let* ((x (car def))(y (si::funid-sym x))) (unless (eq x y) (setq def (cons y (cdr def)))))
-;;     (cmpck (or (endp def) (endp (cdr def))) "The function definition ~s is illegal." def)
-;;     (when labels
-;;       (cmpck (member (car def) fnames) "The function ~s was already defined." (car def))
-;;       (push (car def) fnames))
-;;     (let* ((src (si::block-lambda (cadr def) (car def) (cddr def)))
-;; 	   (fun (make-fun :name (car def) :src src :info (make-info :type nil :sp-change 1))))
-;;       (push fun *funs*)
-;;       (push (list fun (cdr def)) defs1)))
-  
-;;   (let ((*funs* (if labels *funs* ofuns)))
-;; ;    (mapc (lambda (x &aux (x (car x))) (setf (fun-fn x) (afe (cons 'df (current-env)) (mf (fun-name x))))) defs1))
-;;     (mapc (lambda (x &aux (x (car x))) (setf (fun-fn x) (mf (fun-name x)))) defs1))
-
-;;   (multiple-value-setq (body ss ts is other-decl) (c1body (cdr args) t))
-  
-;;   (c1add-globals ss)
-;;   (check-vdecl nil ts is)
-;;   (setq body (c1decl-body other-decl body))
-  
-;;   (let ((nf (mapcar 'car defs1)))
-;;     (ref-funs body nf)
-;;     (when labels
-;;       (do (fun) ((not (setq fun (car (member-if (lambda (x) (or (fun-ref x) (fun-ref-ccb x))) nf)))))
-;; 	  (setq nf (remove fun nf))
-;; 	  (when (fun-ref fun)
-;; 	    (ref-funs (fun-c1 fun) nf))
-;; 	  (when (fun-ref-ccb fun)
-;; 	    (ref-funs (fun-c1cb fun) nf)))))
-
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (let ((funs (mapcar 'car defs1)))
-;;     (list (if labels 'labels 'flet) info 
-;; 	  (mapcar (lambda (x) (caddr (fun-c1   x))) (remove-if-not 'fun-ref funs))
-;; 	  (mapcar (lambda (x) (caddr (fun-c1cb x))) (remove-if-not 'fun-ref-ccb funs))
-;; 	  body)))
-
-;; (defun c1flet-labels (labels args &aux body ss ts is other-decl (info (make-info))
-;; 			     defs1 fnames (ofuns *funs*) (*funs* *funs*))
-
-;;   (when (endp args) (too-few-args 'flet 1 0))
-
-;;   (dolist (def (car args) (setq defs1 (nreverse defs1)))
-;;     (let* ((x (car def))(y (si::funid-sym x))) (unless (eq x y) (setq def (cons y (cdr def)))))
-;;     (cmpck (or (endp def) (endp (cdr def))) "The function definition ~s is illegal." def)
-;;     (when labels
-;;       (cmpck (member (car def) fnames) "The function ~s was already defined." (car def))
-;;       (push (car def) fnames))
-;;     (let* ((src (si::block-lambda (cadr def) (car def) (cddr def)))
-;; 	   (fun (make-fun :name (car def) :src src :info (make-info :type nil :sp-change 1) :fn (funid-to-fn (car def)))))
-;;       (push fun *funs*)
-;;       (push (list fun (cdr def)) defs1)))
-  
-;;   (let ((*funs* (if labels *funs* ofuns)))
-;;     (mapc (lambda (x &aux (x (car x)))
-;; 	    (setf (fun-c1 x) (c1function (list (fun-src x)) t)
-;; 		  (fun-c1cb x) (copy-list (fun-c1 x)))) defs1))
-  
-;;   (multiple-value-setq (body ss ts is other-decl) (c1body (cdr args) t))
-  
-;;   (c1add-globals ss)
-;;   (check-vdecl nil ts is)
-;;   (setq body (c1decl-body other-decl body))
-  
-;;   (mapc (lambda (x) (add-info info (fun-info (car x)))) defs1)
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (let ((funs (mapcar 'car defs1)))
-;;     (list (if labels 'labels 'flet) info 
-;; 	  (mapcar (lambda (x) (caddr (fun-c1 x))) (remove-if-not 'fun-ref funs))
-;; 	  (mapcar (lambda (x) (caddr (fun-c1cb x))) (remove-if-not 'fun-ref-ccb funs))
-;; 	  body)))
-
-;; (defun c1flet-labels (labels args &aux body ss ts is other-decl (info (make-info))
-;; 			     defs1 fnames (ofuns *funs*) (*funs* *funs*))
-
-;;   (when (endp args) (too-few-args 'flet 1 0))
-
-;;   (dolist (def (car args) (setq defs1 (nreverse defs1)))
-;;     (let* ((x (car def))(y (si::funid-sym x))) (unless (eq x y) (setq def (cons y (cdr def)))))
-;;     (cmpck (or (endp def) (endp (cdr def))) "The function definition ~s is illegal." def)
-;;     (when labels
-;;       (cmpck (member (car def) fnames) "The function ~s was already defined." (car def))
-;;       (push (car def) fnames))
-;;     (let* ((src (si::block-lambda (cadr def) (car def) (cddr def)))
-;; 	   (fun (make-fun :name (car def) :src src :info (make-info :type nil :sp-change 1) :fn (funid-to-fn src))))
-;;       (push fun *funs*)
-;;       (push (list fun (cdr def)) defs1)))
-  
-;;   (let ((*funs* (if labels *funs* ofuns)))
-;;     (mapc (lambda (x &aux (x (car x))) (setf (fun-prov x) (c1function (list (fun-src x)) t))) defs1))
-;; ;    (mapc (lambda (x) (setf (fun-denv (car x)) (current-env))) defs1))
-  
-;;   (multiple-value-setq (body ss ts is other-decl) (c1body (cdr args) t))
-  
-;;   (c1add-globals ss)
-;;   (check-vdecl nil ts is)
-;;   (setq body (c1decl-body other-decl body))
-  
-;;   (mapc (lambda (x) (add-info info (fun-info (car x)))) defs1)
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (let ((funs (mapcar 'car defs1)))
-;;     (list (if labels 'labels 'flet) info 
-;; 	  (mapcar 'fun-c1 (remove-if-not 'fun-ref funs))
-;; 	  (mapcar 'fun-c1cb (remove-if-not 'fun-ref-ccb funs))
-;; 	  body)))
+	body)))
 
 
 (defun c1flet (args)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpfun.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpfun.lsp
@@ -363,47 +363,10 @@
 	  ((member test `(equal ,#'equal)) '(equal-is-eq equal-is-eq-tp))
 	  ((member test `(equalp ,#'equalp)) '(equalp-is-eq equalp-is-eq-tp)))))
 
-(defun do-predicate (fn args)
-  (let* ((info (make-info :type #tboolean))
-	 (nargs (c1args args info))
-	 (tp (car (rassoc fn +cmp-type-alist+))))
-    (when (cdr args) (baboon))
-    (let ((at (nil-to-t (coerce-to-one-value (info-type (cadar nargs))))))
-      (cond ((type>= tp at) (c1expr (ignorable-pivot (car args) t)))
-	    ((not (type-and at tp)) (c1expr (ignorable-pivot (car args) nil)))
-	    ((list 'call-global info fn nargs))))))
-
 (defun cons-type-length (type)
   (cond ((and (consp type) (eq (car type) 'cons)) (the seqind (+ 1 (cons-type-length (caddr type)))))
 	(0)))
 
-
-
-(defun co1eql (f args)
-  (declare (ignore f))
-  (or (and (cdr args) (not *safe-compile*))
-      (return-from co1eql nil))
-  (cond ((replace-constant args)
-	 (cond ((characterp (second args))
-		(setq args (reverse args))))
-	 (cond ((characterp (car args))
-		(let ((c (sgen "CO1EQL")))
-		  (c1expr
-		   `(let ((,c ,(second args)))
-		      (declare (type ,(result-type (second args))
-				     ,c))
-		      (and (typep ,c 'character)
-			   (= (char-code ,(car args))
-			      (the fixnum
-				   (char-code
-				    (the character
-					 ,c)))
-			      ))))))))))
-
-
-	 
-(si::putprop 'eql 'co1eql 'co1)		    
-
 (defvar *frozen-defstructs* nil)
 
 ;; Return the most particular type we can EASILY obtain
@@ -428,24 +391,29 @@
 (si::putprop 'cons 'co1cons 'co1)
 ;; turn repetitious cons's into a list*
 
-(defun cons-to-lista (x)
-  (let ((tem  (last x)))
-    (cond 
-	((and (consp tem)
-	      (consp (car tem))
-	      (eq (caar tem) 'cons)
-	      (eql (length (cdar tem)) 2)
-	      (cons-to-lista (append (butlast x) (cdar tem)))))
-	(t x))))
-    	 
+(defun cons-to-listc (x)
+  (typecase x
+    ((cons t (cons t null))
+     (let ((y (cadr x)))
+       (typecase y
+	 ((cons (member cons) (cons t (cons t null)))
+	  (let ((d (cons-to-listc (cdr y))))
+	    (when d (cons (car x) d))))
+	 (otherwise x))))))
+
+(defun limit-list-call-args (form &aux (of form)(fn (pop of))
+				    (x (nthcdr (1- call-arguments-limit) of)))
+  (if x
+      `(nconc (list ,@(ldiff of x)) ,(limit-list-call-args (cons fn x)))
+      form))
 
-(defun co1cons (f args)
+(defun co1cons (f args &aux (tem (cons-to-listc args)))
   (declare (ignore f))
-  (let ((tem (and (eql (length args) 2) (cons-to-lista args))))
-    (and tem (not (eq tem args))
-	 (c1expr  (if (equal '(nil) (last tem))
-		     (cons 'list (butlast tem))
-		     (cons 'list* tem))))))
+  (when tem
+    (c1expr (limit-list-call-args
+	     (if (equal '(nil) (last tem))
+		 (cons 'list (butlast tem))
+		 (cons 'list* tem))))))
 
 ;; Facilities for faster reading and writing from file streams.
 ;; You must declare the stream to be :in-file
@@ -606,6 +574,7 @@
 (si::putprop 'list 'c1list 'c1)
       
 (defun c1list* (args)
+  (unless args (too-few-args 'list* 1 0))
   (let* ((info (make-info))
 	 (nargs (c1args args info)))
     (cond ((not nargs) (c1nil))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpinline.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpinline.lsp
@@ -1046,11 +1046,11 @@
 				    (list 'var *mv-var* nil))
 				   ((list 'vs-address "base" (cdr (vs-push)))))))
 			   ((setq n (digit-char-p ch))
-			    (let* ((ii (+ i 2))
-				   (m (when (> (length fun) ii) (digit-char-p (setq ch (char fun ii))))))
-			      (when m (setq n (+ (* n 10) m) i (1+ i)))
-			      (setq max (max max (1+ n)))
-			      (let ((*values-to-go* nil)) (wt-loc (nth n locs)))))
+			    (do (m (ii (+ i 2) (1+ ii)))
+				((not (setq m (when (> (length fun) ii) (digit-char-p (setq ch (char fun ii))))))
+				 (setq max (max max (1+ n)))
+				 (let ((*values-to-go* nil)) (wt-loc (nth n locs))))
+			      (setq n (+ (* n 10) m) i (1+ i))))
 			   ((wt ch))))
 			(incf i 2))
 		       ((char= char #\@);FIXME better error checking
@@ -1139,6 +1139,7 @@
 	     (wt-nl "_p->c_car=" x ";_p->c_cdr=(object)(_p+1);_p++;"))))))
 
 (defun list-inline (&rest x &aux (*values-to-go* nil))
+  (assert x)
   (cond ((can-allocate-on-stack) (wt-stack-list* x nil))
 	((endp (cdr x)) (wt "make_cons(" (car x) ",Cnil)"))
 	(t 
@@ -1146,6 +1147,7 @@
 	 (dolist (loc x (wt #\))) (wt #\, loc)))))
 
 (defun list*-inline (&rest x &aux (*values-to-go* nil))
+  (assert x)
   (if (can-allocate-on-stack)
       (wt-stack-list* (butlast x) (car (last x)))
     (case (length x)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmplabel.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmplabel.lsp
@@ -68,7 +68,8 @@
   (when (and (eq loc 'fun-val)
              (not (eq *value-to-go* 'return))
 	     (not (rassoc *value-to-go* +return-alist+))
-             (not (eq *value-to-go* 'top)))
+             (not (eq *value-to-go* 'top))
+	     (not (multiple-values-p)));FIXME cleanup
         (wt-nl) (reset-top))
   (cond ((and (consp *value-to-go*) (eq (car *value-to-go*) 'jump-true))
          (set-jump-true loc (cadr *value-to-go*))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmplam.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmplam.lsp
@@ -113,668 +113,6 @@
   
   `(lambda ,info ,(list (nreverse requireds) narg) ,doc ,body))
 
-;; (defun c1lambda-expr (args &aux (regs (pop args)) requireds tv
-;; 			   doc body ss is ts other-decls (ovars *vars*)
-;; 			   (*vars* *vars*) narg (info (make-info)) ctps)
-
-
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps) (c1body args t));FIXME parse-body-header
-  
-;;   (mapc (lambda (x &aux (y (c1make-var x ss is ts))) (push-var y nil) (push y requireds)) regs)
-;;   (when (member +nargs+ ts :key 'car)
-;;     (setq narg (list (c1make-var +nargs+ ss is ts))))
-;;   (setq tv (append narg requireds))
-
-;;   (c1add-globals ss)
-;;   (check-vdecl (mapcar 'var-name tv) ts is)
-  
-;;   (setq body (c1decl-body other-decls body))
-;;   (ref-vars body requireds)
-;;   (dolist (var requireds) (check-vref var))
-  
-;;   (dolist (v requireds)
-;;     (when (var-p v)
-;;       (setf (var-type v) (var-mt v))));FIXME?
-;;   (let ((*vars* ovars)) (add-info info (cadr body)))
-;;   (cond (*compiler-new-safety*
-;; 	 (mapc (lambda (x) (setf (var-type x) #tt)) requireds)
-;; 	 (let ((i (cadr body)))
-;; 	   (setf (info-type i) (if (single-type-p (info-type i)) #tt #t*))))
-;; 	((mapc (lambda (l) (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps)))))) tv)));FIXME?
-  
-;;   `(lambda ,info ,(list (nreverse requireds) narg) ,doc ,body))
-
-;; (defun c1lambda-expr (args &aux (regs (pop args)) requireds tv
-;; 			   doc body ss is ts other-decls (ovars *vars*)
-;; 			   (*vars* *vars*) narg (info (make-info)) ctps)
-
-
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps) (c1body args t));FIXME parse-body-header
-  
-;;   (mapc (lambda (x &aux (y (c1make-var x ss is ts))) (push-var y nil) (push y requireds)) regs)
-;;   (when (member +nargs+ ts :key 'car)
-;;     (setq narg (list (c1make-var +nargs+ ss is ts))))
-;;   (setq tv (append narg requireds))
-
-;;   (c1add-globals ss)
-;;   (check-vdecl (mapcar 'var-name tv) ts is)
-  
-;;   (setq body (c1decl-body other-decls body))
-;;   (ref-vars body requireds)
-;;   (dolist (var requireds) (check-vref var))
-  
-;;   (dolist (v requireds)
-;;     (when (var-p v)
-;;       (setf (var-type v) (var-mt v))));FIXME?
-;;   (let ((*vars* ovars)) (add-info info (cadr body)))
-;;   (unless *compiler-new-safety*
-;;     (dolist (l tv) 
-;;       (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps)))))));FIXME?
-  
-;;   `(lambda ,info ,(list (nreverse requireds) narg) ,doc ,body))
-
-;; (defun c1lambda-expr (args &aux (regs (pop args)) requireds tv
-;; 			   doc body ss is ts other-decls (ovars *vars*)
-;; 			   (*vars* *vars*) narg (info (make-info)) ctps)
-
-
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps) (c1body args t));FIXME parse-body-header
-  
-;;   (mapc (lambda (x &aux (y (c1make-var x ss is ts))) (push-var y nil) (push y requireds)) regs)
-;;   (when (member +nargs+ ts :key 'car)
-;;     (setq narg (list (c1make-var +nargs+ ss is ts))))
-;;   (setq tv (append narg requireds))
-
-;;   (c1add-globals ss)
-;;   (check-vdecl (mapcar 'var-name tv) ts is)
-  
-;;   (setq body (c1decl-body other-decls body))
-;;   (ref-vars body requireds)
-;;   (dolist (var requireds) (check-vref var))
-  
-;;   (dolist (v requireds)
-;;     (when (var-p v)
-;;       (setf (var-type v) (var-mt v))));FIXME?
-;;   (let ((*vars* ovars)) (add-info info (cadr body)))
-;;   (dolist (l tv) 
-;;     (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps))))));FIXME?
-  
-;;   `(lambda ,info ,(list (nreverse requireds) narg) ,doc ,body))
-
-;; (defun c1lambda-expr (args &aux (regs (pop args)) requireds tv
-;; 			   doc body ss is ts other-decls (ovars *vars*)
-;; 			   (*vars* *vars*) narg (info (make-info)) ctps)
-
-
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps) (c1body args t));FIXME parse-body-header
-  
-;;   (mapc (lambda (x &aux (y (c1make-var x ss is ts))) (push y *vars*) (push y requireds)) regs)
-;;   (when (member +nargs+ ts :key 'car)
-;;     (setq narg (list (c1make-var +nargs+ ss is ts))))
-;;   (setq tv (append narg requireds))
-
-;;   (c1add-globals ss)
-;;   (check-vdecl (mapcar 'var-name tv) ts is)
-  
-;;   (setq body (c1decl-body other-decls body))
-;;   (ref-vars body requireds)
-;;   (dolist (var requireds) (check-vref var))
-  
-;;   (dolist (v requireds)
-;;     (when (var-p v)
-;;       (setf (var-type v) (var-mt v))));FIXME?
-;;   (let ((*vars* ovars)) (add-info info (cadr body)))
-;;   (dolist (l tv) 
-;;     (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps))))));FIXME?
-  
-;;   `(lambda ,info ,(list (nreverse requireds) narg) ,doc ,body))
-
-;; (defun c1lambda-expr (args &aux (regs (pop args)) requireds tv
-;; 			   doc body ss is ts other-decls
-;; 			   (*vars* *vars*) narg (info (make-info)) ctps)
-
-
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps) (c1body args t));FIXME parse-body-header
-  
-;;   (mapc (lambda (x &aux (y (c1make-var x ss is ts))) (push y *vars*) (push y requireds)) regs)
-;;   (when (member +nargs+ ts :key 'car)
-;;     (setq narg (list (c1make-var +nargs+ ss is ts))))
-;;   (setq tv (append narg requireds))
-
-;;   (c1add-globals ss)
-;;   (check-vdecl (mapcar 'var-name tv) ts is)
-  
-;;   (setq body (c1decl-body other-decls body))
-;;   (ref-vars body requireds)
-;;   (dolist (var requireds) (check-vref var))
-  
-;;   (dolist (v requireds)
-;;     (when (var-p v)
-;;       (setf (var-type v) (var-mt v))));FIXME?
-;;   (add-info info (cadr body))
-;;   (dolist (l tv) 
-;;     (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps))))));FIXME?
-  
-;;   `(lambda ,info ,(list (nreverse requireds) narg) ,doc ,body))
-
-;; (defun c1lambda-expr (lambda-expr
-;;                       &optional (block-name nil block-it)
-;;                       &aux (requireds nil) (optionals nil) (rest nil)
-;;                            (keywords nil) (key-flag nil)
-;; 			   lambda-list
-;;                            (allow-other-keys nil) (aux-vars nil)
-;;                            (aux-inits nil) doc vl spec body ss is ts
-;;                            other-decls vnames
-;;                            (*vars* *vars*)
-;;                            (info (make-info))
-;;                            (aux-info nil)
-;; 			   (setjmps *setjmps*) ctps)
-
-;;   (cmpck (endp lambda-expr)
-;;          "The lambda expression ~s is illegal." (cons 'lambda lambda-expr))
-
-
-;;   ;;FIXME -- this is backwards, as the proclamations should be
-;;   ;;generated from the declarations.  What we need here and in the let
-;;   ;;code is reverse type propagation.  CM 20050106
-;; ;;   (let ((decls (decls-from-procls
-;; ;; 		(car lambda-expr)
-;; ;; 		(and block-it (get-arg-types block-name))
-;; ;; 		(cdr lambda-expr))))
-;; ;;     (when decls
-;; ;;       (cmpnote "~S function args declared: ~S~%" block-name decls)
-;; ;;       (setq lambda-expr (cons (car lambda-expr) (cons (cons 'declare decls) (cdr lambda-expr))))))
-    
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps)
-;;                        (c1body (cdr lambda-expr) t))
-  
-;;   (when block-it (setq body (list (cons 'block (cons block-name body)))))
-
-;;   (c1add-globals ss)
-
-;;   (setq vl (car lambda-expr))
-;;   (block parse
-;;    (tagbody
-;;     Lreq
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&optional (go Lopt))
-;;             (&rest (go Lrest))
-;;             (&key (go Lkey))
-;;             (&aux (go Laux)))
-;;       (let ((v (c1make-var spec ss is ts)))
-;;            (push spec vnames)
-;;            (push v *vars*)
-;;            (push v requireds))
-;;       (go Lreq)
-
-;;     Lopt
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&rest (go Lrest))
-;;             (&key (go Lkey))
-;;             (&aux (go Laux)))
-;;       (cond ((not (consp spec))
-;;              (let ((v (c1make-var spec ss is ts)))
-;;                   (push spec vnames)
-;;                   (push (list v (default-init (var-type v)) nil) optionals)
-;;                   (push v *vars*)))
-;;             ((not (consp (cdr spec)))
-;;              (ck-spec (null (cdr spec)))
-;;              (let ((v (c1make-var (car spec) ss is ts)))
-;;                   (push (car spec) vnames)
-;;                   (push (list v (default-init (var-type v)) nil) optionals)
-;;                   (push v *vars*)))
-;;             ((not (consp (cddr spec)))
-;;              (ck-spec (null (cddr spec)))
-;;              (let ((init (c1expr* (cadr spec) info))
-;;                    (v (c1make-var (car spec) ss is ts)))
-;;                   (push (car spec) vnames)
-;;                   (push
-;;                    (list v (and-form-type (var-type v) init (cadr spec)) nil)
-;;                    optionals)
-;;                   (push v *vars*)))
-;;             (t
-;;              (ck-spec (null (cdddr spec)))
-;;              (let ((init (c1expr* (cadr spec) info))
-;;                    (v (c1make-var (car spec) ss is ts))
-;;                    (sv (c1make-var (caddr spec) ss is ts))
-;;                    )
-;;                   (push (car spec) vnames)
-;;                   (push (caddr spec) vnames)
-;;                   (push
-;;                    (list v (and-form-type (var-type v) init (cadr spec)) sv)
-;;                    optionals)
-;;                   (push v *vars*)
-;;                   (push sv *vars*))))
-;;       (go Lopt)
-
-;;     Lrest
-;;       (ck-vl (consp vl))
-;;       (push (car vl) vnames)
-;;       (setq rest (c1make-var (pop vl) ss is ts))
-;;       (push rest *vars*)
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&key (go Lkey))
-;;             (&aux (go Laux)))
-;;       (cmperr "Either &key or &aux is missing before ~s." spec)
-
-;;     Lkey
-;;       (setq key-flag t)
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&aux (go Laux))
-;;             (&allow-other-keys (setq allow-other-keys t)
-;;                                (when (null vl) (return-from parse))
-;;                                (ck-vl (consp vl))
-;;                                (case (setq spec (pop vl))
-;;                                      (&aux (go Laux)))
-;;                                (cmperr "&aux is missing before ~s." spec)))
-;;       (when (not (consp spec)) (setq spec (list spec)))
-;;       (cond ((consp (car spec))
-;;              (ck-spec (and (keywordp (caar spec))
-;;                            (consp (cdar spec))
-;;                            (null (cddar spec))))
-;;              (setq spec (cons (caar spec) (cons (cadar spec) (cdr spec)))))
-;;             (t
-;;              (ck-spec (symbolp (car spec)))
-;;              (setq spec (cons (intern (string (car spec)) 'keyword)
-;;                               (cons (car spec) (cdr spec))))))
-;;       (cond ((not (consp (cddr spec)))
-;;              (ck-spec (null (cddr spec)))
-;;              (let ((v (c1make-var (cadr spec) ss is ts)))
-;;                   (push (cadr spec) vnames)
-;;                   (push
-;;                    (list (car spec) v (default-init (var-type v))
-;;                          (make-var :kind 'DUMMY))
-;;                    keywords)
-;;                   (push v *vars*)))
-;;             ((not (consp (cdddr spec)))
-;;              (ck-spec (null (cdddr spec)))
-;;              (let ((init (c1expr* (caddr spec) info))
-;;                    (v (c1make-var (cadr spec) ss is ts)))
-;;                   (push (cadr spec) vnames)
-;;                   (push (list (car spec) v
-;;                               (and-form-type (var-type v) init (caddr spec))
-;;                               (make-var :kind 'DUMMY))
-;;                         keywords)
-;;                   (push v *vars*)))
-;;             (t
-;;              (ck-spec (null (cddddr spec)))
-;;              (let ((init (c1expr* (caddr spec) info))
-;;                    (v (c1make-var (cadr spec) ss is ts))
-;;                    (sv (c1make-var (cadddr spec) ss is ts)))
-;;                   (push (cadr spec) vnames)
-;;                   (push (cadddr spec) vnames)
-;;                   (push (list (car spec) v
-;;                               (and-form-type (var-type v) init (caddr spec))
-;;                               sv)
-;;                         keywords)
-;;                   (push v *vars*)
-;;                   (push sv *vars*))))
-;;       (go Lkey)
-
-;;     Laux
-;;       (setq aux-info (make-info))
-;;     Laux1
-;;       (when (null vl) (add-info info aux-info) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (setq spec (pop vl))
-;;       (cond ((consp spec)
-;;              (cond ((not (consp (cdr spec)))
-;;                     (ck-spec (null (cdr spec)))
-;;                     (let ((v (c1make-var (car spec) ss is ts)))
-;;                          (push (car spec) vnames)
-;;                          (push (default-init (var-type v)) aux-inits)
-;;                          (push v aux-vars)
-;;                          (push v *vars*)))
-;;                    (t
-;;                     (ck-spec (null (cddr spec)))
-;;                     (let ((init (c1expr* (cadr spec) aux-info))
-;;                           (v (c1make-var (car spec) ss is ts)))
-;;                          (push (car spec) vnames)
-;;                          (push (and-form-type (var-type v) init (cadr spec))
-;;                                aux-inits)
-;;                          (push v aux-vars)
-;;                          (push v *vars*)))))
-;;             (t
-;;              (let ((v (c1make-var spec ss is ts)))
-;;                   (push spec vnames)
-;;                   (push (default-init (var-type v)) aux-inits)
-;;                   (push v aux-vars)
-;;                   (push v *vars*))))
-;;       (set-var-init-type (car aux-vars) (info-type (second (car aux-inits))))
-;;       (go Laux1)
-;;       )
-;;    )
-;;   (setq requireds (reverse requireds)
-;;         optionals (reverse optionals)
-;;         keywords (reverse keywords)
-;;         aux-vars (reverse aux-vars)
-;;         aux-inits (reverse aux-inits))
-
-;;   (check-vdecl vnames ts is)
-
-;;   (setq body (c1decl-body other-decls body))
-
-;;   (ref-vars body (append requireds optionals keywords aux-vars));FIXME aux?
-
-;;   (dolist (l (list requireds optionals keywords aux-vars))
-;;     (dolist (v l)
-;;       (when (var-p v)
-;; 	(setf (var-type v) (var-mt v)))))
-
-;;   (add-info info (cadr body))
-
-;;   (dolist** (var requireds) (check-vref var))
-;;   (dolist** (opt optionals)
-;;             (check-vref (car opt))
-;;             (when (caddr opt) (check-vref (caddr opt))))
-;;   (when rest (check-vref rest))
-;;   (dolist** (kwd keywords)
-;;             (check-vref (cadr kwd))
-;;             (when (cadddr kwd) (check-vref (cadddr kwd))))
-;;   (dolist** (var aux-vars) (check-vref var))
-  
-;;   (when aux-vars
-;;         (add-info aux-info (cadr body))
-;; 	(setf (info-type aux-info) (info-type (cadr body)))
-;;         (setq body (list 'let* aux-info aux-vars aux-inits body))
-;; 	(or (eql setjmps *setjmps*) (setf (info-volatile aux-info) 1)))
-
-;;   ;;FIXME -- is above for aux needed too?
-;;   (when (or optionals keywords)
-;;     (or (eql setjmps *setjmps*) (setf (info-volatile info) 1)))
-;;   (setq optionals (list (is-narg-le lambda-expr)));FIXME
-;;   (setq lambda-list
-;; 	(list requireds optionals rest key-flag keywords allow-other-keys))
-;;   (dolist (l requireds) 
-;;     (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps))))));(unboxed-type (cdr (assoc (var-name l) ctps)))
-;;   (and *record-call-info* (record-arg-info lambda-list))
-;;   `(lambda ,info ,lambda-list ,doc ,body))
-
-;; (defun c1lambda-expr (args
-;;                       &optional (block-name nil block-it)
-;;                       &aux (regs (pop args)) requireds
-;; 		      lambda-list doc vl spec body ss is ts
-;; 		      other-decls vnames
-;; 		      (*vars* *vars*)
-;; 		      (info (make-info)) ctps)
-
-
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps) (c1body args t))
-  
-;;   (mapc (lambda (x &aux (y (c1make-var x ss is ts))) (push y *vars*) (push y requireds)) regs)
-
-;;   (c1add-globals ss)
-  
-;;   (check-vdecl requireds ts is)
-  
-;;   (setq body (c1decl-body other-decls body))
-  
-;;   (ref-vars body requireds)
-  
-;;   (dolist (v requireds)
-;;     (when (var-p v)
-;;       (setf (var-type v) (var-mt v))))
-  
-;;   (add-info info (cadr body))
-  
-;;   (dolist (var requireds) (check-vref var))
-  
-;;   (let* ((narg (is-narg-le args)))
-;;     (when narg (print (list 'narg block-name)))
-;;     (setq lambda-list (list (nreverse requireds) (when narg (list +nargs+)))))
-;;   (dolist (l requireds) 
-;;     (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps))))));(unboxed-type (cdr (assoc (var-name l) ctps)))
-  
-;;   `(lambda ,info ,lambda-list ,doc ,body))
-
-;; (defun c1lambda-expr (lambda-expr
-;;                       &optional (block-name nil block-it)
-;;                       &aux (requireds nil) (optionals nil) (rest nil)
-;;                            (keywords nil) (key-flag nil)
-;; 			   lambda-list
-;;                            (allow-other-keys nil) (aux-vars nil)
-;;                            (aux-inits nil) doc vl spec body ss is ts
-;;                            other-decls vnames
-;;                            (*vars* *vars*)
-;;                            (info (make-info))
-;;                            (aux-info nil)
-;; 			   (setjmps *setjmps*) ctps
-;;                       )
-
-;;   (cmpck (endp lambda-expr)
-;;          "The lambda expression ~s is illegal." (cons 'lambda lambda-expr))
-
-
-;;   ;;FIXME -- this is backwards, as the proclamations should be
-;;   ;;generated from the declarations.  What we need here and in the let
-;;   ;;code is reverse type propagation.  CM 20050106
-;; ;;   (let ((decls (decls-from-procls
-;; ;; 		(car lambda-expr)
-;; ;; 		(and block-it (get-arg-types block-name))
-;; ;; 		(cdr lambda-expr))))
-;; ;;     (when decls
-;; ;;       (cmpnote "~S function args declared: ~S~%" block-name decls)
-;; ;;       (setq lambda-expr (cons (car lambda-expr) (cons (cons 'declare decls) (cdr lambda-expr))))))
-    
-;;   (multiple-value-setq (body ss ts is other-decls doc ctps)
-;;                        (c1body (cdr lambda-expr) t))
-  
-;;   (when block-it (setq body (list (cons 'block (cons block-name body)))))
-
-;;   (c1add-globals ss)
-
-;;   (setq vl (car lambda-expr))
-;;   (block parse
-;;    (tagbody
-;;     Lreq
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&optional (go Lopt))
-;;             (&rest (go Lrest))
-;;             (&key (go Lkey))
-;;             (&aux (go Laux)))
-;;       (let ((v (c1make-var spec ss is ts)))
-;;            (push spec vnames)
-;;            (push v *vars*)
-;;            (push v requireds))
-;;       (go Lreq)
-
-;;     Lopt
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&rest (go Lrest))
-;;             (&key (go Lkey))
-;;             (&aux (go Laux)))
-;;       (cond ((not (consp spec))
-;;              (let ((v (c1make-var spec ss is ts)))
-;;                   (push spec vnames)
-;;                   (push (list v (default-init (var-type v)) nil) optionals)
-;;                   (push v *vars*)))
-;;             ((not (consp (cdr spec)))
-;;              (ck-spec (null (cdr spec)))
-;;              (let ((v (c1make-var (car spec) ss is ts)))
-;;                   (push (car spec) vnames)
-;;                   (push (list v (default-init (var-type v)) nil) optionals)
-;;                   (push v *vars*)))
-;;             ((not (consp (cddr spec)))
-;;              (ck-spec (null (cddr spec)))
-;;              (let ((init (c1expr* (cadr spec) info))
-;;                    (v (c1make-var (car spec) ss is ts)))
-;;                   (push (car spec) vnames)
-;;                   (push
-;;                    (list v (and-form-type (var-type v) init (cadr spec)) nil)
-;;                    optionals)
-;;                   (push v *vars*)))
-;;             (t
-;;              (ck-spec (null (cdddr spec)))
-;;              (let ((init (c1expr* (cadr spec) info))
-;;                    (v (c1make-var (car spec) ss is ts))
-;;                    (sv (c1make-var (caddr spec) ss is ts))
-;;                    )
-;;                   (push (car spec) vnames)
-;;                   (push (caddr spec) vnames)
-;;                   (push
-;;                    (list v (and-form-type (var-type v) init (cadr spec)) sv)
-;;                    optionals)
-;;                   (push v *vars*)
-;;                   (push sv *vars*))))
-;;       (go Lopt)
-
-;;     Lrest
-;;       (ck-vl (consp vl))
-;;       (push (car vl) vnames)
-;;       (setq rest (c1make-var (pop vl) ss is ts))
-;;       (push rest *vars*)
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&key (go Lkey))
-;;             (&aux (go Laux)))
-;;       (cmperr "Either &key or &aux is missing before ~s." spec)
-
-;;     Lkey
-;;       (setq key-flag t)
-;;       (when (null vl) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (case (setq spec (pop vl))
-;;             (&aux (go Laux))
-;;             (&allow-other-keys (setq allow-other-keys t)
-;;                                (when (null vl) (return-from parse))
-;;                                (ck-vl (consp vl))
-;;                                (case (setq spec (pop vl))
-;;                                      (&aux (go Laux)))
-;;                                (cmperr "&aux is missing before ~s." spec)))
-;;       (when (not (consp spec)) (setq spec (list spec)))
-;;       (cond ((consp (car spec))
-;;              (ck-spec (and (keywordp (caar spec))
-;;                            (consp (cdar spec))
-;;                            (null (cddar spec))))
-;;              (setq spec (cons (caar spec) (cons (cadar spec) (cdr spec)))))
-;;             (t
-;;              (ck-spec (symbolp (car spec)))
-;;              (setq spec (cons (intern (string (car spec)) 'keyword)
-;;                               (cons (car spec) (cdr spec))))))
-;;       (cond ((not (consp (cddr spec)))
-;;              (ck-spec (null (cddr spec)))
-;;              (let ((v (c1make-var (cadr spec) ss is ts)))
-;;                   (push (cadr spec) vnames)
-;;                   (push
-;;                    (list (car spec) v (default-init (var-type v))
-;;                          (make-var :kind 'DUMMY))
-;;                    keywords)
-;;                   (push v *vars*)))
-;;             ((not (consp (cdddr spec)))
-;;              (ck-spec (null (cdddr spec)))
-;;              (let ((init (c1expr* (caddr spec) info))
-;;                    (v (c1make-var (cadr spec) ss is ts)))
-;;                   (push (cadr spec) vnames)
-;;                   (push (list (car spec) v
-;;                               (and-form-type (var-type v) init (caddr spec))
-;;                               (make-var :kind 'DUMMY))
-;;                         keywords)
-;;                   (push v *vars*)))
-;;             (t
-;;              (ck-spec (null (cddddr spec)))
-;;              (let ((init (c1expr* (caddr spec) info))
-;;                    (v (c1make-var (cadr spec) ss is ts))
-;;                    (sv (c1make-var (cadddr spec) ss is ts)))
-;;                   (push (cadr spec) vnames)
-;;                   (push (cadddr spec) vnames)
-;;                   (push (list (car spec) v
-;;                               (and-form-type (var-type v) init (caddr spec))
-;;                               sv)
-;;                         keywords)
-;;                   (push v *vars*)
-;;                   (push sv *vars*))))
-;;       (go Lkey)
-
-;;     Laux
-;;       (setq aux-info (make-info))
-;;     Laux1
-;;       (when (null vl) (add-info info aux-info) (return-from parse))
-;;       (ck-vl (consp vl))
-;;       (setq spec (pop vl))
-;;       (cond ((consp spec)
-;;              (cond ((not (consp (cdr spec)))
-;;                     (ck-spec (null (cdr spec)))
-;;                     (let ((v (c1make-var (car spec) ss is ts)))
-;;                          (push (car spec) vnames)
-;;                          (push (default-init (var-type v)) aux-inits)
-;;                          (push v aux-vars)
-;;                          (push v *vars*)))
-;;                    (t
-;;                     (ck-spec (null (cddr spec)))
-;;                     (let ((init (c1expr* (cadr spec) aux-info))
-;;                           (v (c1make-var (car spec) ss is ts)))
-;;                          (push (car spec) vnames)
-;;                          (push (and-form-type (var-type v) init (cadr spec))
-;;                                aux-inits)
-;;                          (push v aux-vars)
-;;                          (push v *vars*)))))
-;;             (t
-;;              (let ((v (c1make-var spec ss is ts)))
-;;                   (push spec vnames)
-;;                   (push (default-init (var-type v)) aux-inits)
-;;                   (push v aux-vars)
-;;                   (push v *vars*))))
-;;       (set-var-init-type (car aux-vars) (info-type (second (car aux-inits))))
-;;       (go Laux1)
-;;       )
-;;    )
-;;   (setq requireds (reverse requireds)
-;;         optionals (reverse optionals)
-;;         keywords (reverse keywords)
-;;         aux-vars (reverse aux-vars)
-;;         aux-inits (reverse aux-inits))
-
-;;   (check-vdecl vnames ts is)
-
-;;   (setq body (c1decl-body other-decls body))
-
-;;   (dolist (l (list requireds optionals keywords aux-vars))
-;;     (dolist (v l)
-;;       (when (var-p v)
-;; 	(setf (var-type v) (var-mt v)))))
-
-;;   (add-info info (cadr body))
-
-;;   (dolist** (var requireds) (check-vref var))
-;;   (dolist** (opt optionals)
-;;             (check-vref (car opt))
-;;             (when (caddr opt) (check-vref (caddr opt))))
-;;   (when rest (check-vref rest))
-;;   (dolist** (kwd keywords)
-;;             (check-vref (cadr kwd))
-;;             (when (cadddr kwd) (check-vref (cadddr kwd))))
-;;   (dolist** (var aux-vars) (check-vref var))
-  
-;;   (when aux-vars
-;;         (add-info aux-info (cadr body))
-;; 	(setf (info-type aux-info) (info-type (cadr body)))
-;;         (setq body (list 'let* aux-info aux-vars aux-inits body))
-;; 	(or (eql setjmps *setjmps*) (setf (info-volatile aux-info) 1)))
-
-;;   ;;FIXME -- is above for aux needed too?
-;;   (when (or optionals keywords)
-;;     (or (eql setjmps *setjmps*) (setf (info-volatile info) 1)))
-
-;;   (setq lambda-list
-;; 	(list requireds optionals rest key-flag keywords allow-other-keys))
-;;   (dolist (l requireds) 
-;;     (setf (var-type l) (type-and (var-type l) (nil-to-t (cdr (assoc (var-name l) ctps))))));(unboxed-type (cdr (assoc (var-name l) ctps)))
-;;   (and *record-call-info* (record-arg-info lambda-list))
-;;   `(lambda ,info ,lambda-list ,doc ,body))
-
 
 (defun the-parameter (name)
   (cmpck (not (symbolp name)) "The parameter ~s is not a symbol." name)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmplet.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmplet.lsp
@@ -291,241 +291,11 @@
       (if vars (list nm info vars fms body)
 	  (list* (car body) info (cddr body))))))
 
-;; (defun c1let-* (args &optional star inls
-;; 		     &aux (nm (if star 'let* 'let))
-;; 		     (ov *vars*) (*vars* *vars*) (setjmps *setjmps*)
-;; 		     ss is ts body other-decls
-;; 		     (info (make-info)))
-
-;;   (when (endp args) (too-few-args nm 1 0))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cdr args) nil))
-
-;;   (let* ((vs (nreverse (mvars (car args) ss is ts star inls)))
-;; 	 (vars (mapcar 'car vs))
-;; 	 (forms (mapcar 'cdr vs))
-;; 	 (vnames (mapcar 'var-name vars))
-;; 	 (*vars* (if star *vars* (append vars *vars*))))
-
-;;     (c1add-globals (set-difference ss vnames))
-;;     (check-vdecl vnames ts is)
-;;     (setq body (c1decl-body other-decls body))
-
-;;     (unless (single-type-p (info-type (cadr body))) 
-;;       (let ((mv (car (member-if 'is-mv-var vars))))
-;; 	(when mv
-;; 	  (ref-vars (c1var (var-name mv)) (list mv)))))
-
-;;     (ref-vars body vars)
-
-;;     (dolist (var vars) (setf (var-type var) (var-mt var)));FIXME?
- 
-;;     (let* ((*vars* ov)
-;; 	   (z (trim-vars vars forms body star))
-;; 	   (vars (pop z))
-;; 	   (fms (pop z))
-;; 	   (body (car z)))
-      
-;;       (dolist (fm fms) (add-info info (cadr fm)))
-;;       (add-info info (cadr body))
-      
-;;       (setf (info-type info) (info-type (cadr body)))
-;;       (unless (eq setjmps *setjmps*) (setf (info-volatile info) 1))
-      
-;;       (if vars (c1replace (list nm info vars fms body))
-;; 	(list* (car body) info (cddr body))))))
-
-;; (defun c1let-* (args &optional star inls
-;; 		     &aux (nm (if star 'let* 'let))
-;; 		     (ov *vars*) (*vars* *vars*) (setjmps *setjmps*)
-;; 		     ss is ts body other-decls
-;; 		     (info (make-info)))
-
-;;   (when (endp args) (too-few-args nm 1 0))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cdr args) nil))
-
-;;   (let* ((vs (nreverse (mvars (car args) ss is ts star inls)))
-;; 	 (vars (mapcar 'car vs))
-;; 	 (forms (mapcar 'cdr vs))
-;; 	 (vnames (mapcar 'var-name vars))
-;; 	 (*vars* (if star *vars* (append vars *vars*))))
-
-;;     (c1add-globals (set-difference ss vnames))
-;;     (check-vdecl vnames ts is)
-;;     (setq body (c1decl-body other-decls body))
-
-;;     (unless (single-type-p (info-type (cadr body))) 
-;;       (let ((mv (car (member-if 'is-mv-var vars))))
-;; 	(when mv
-;; 	  (ref-vars (c1var (var-name mv)) (list mv)))))
-
-;;     (ref-vars body vars)
-
-;;     (dolist (var vars) (setf (var-type var) (var-mt var)));FIXME?
- 
-;;     (let* ((*vars* ov)
-;; 	   (z (trim-vars vars forms body star))
-;; 	   (vars (pop z))
-;; 	   (fms (pop z))
-;; 	   (body (car z)))
-      
-;;       (dolist (fm fms) (add-info info (cadr fm)))
-;;       (add-info info (cadr body))
-      
-;;       (setf (info-type info) (info-type (cadr body)))
-;;       (unless (eq setjmps *setjmps*) (setf (info-volatile info) 1))
-      
-;;       (if vars (list nm info vars fms body) 
-;; 	(list* (car body) info (cddr body))))))
-
-;; (defun c1let-* (args &optional star env inls
-;; 		     &aux (nm (if star 'let* 'let))
-;; 		     (ov *vars*) (*vars* *vars*) (setjmps *setjmps*)
-;; 		     ss is ts body other-decls
-;; 		     (info (make-info)))
-
-;;   (when (endp args) (too-few-args nm 1 0))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cdr args) nil))
-
-;;   (let* ((vs (nreverse (mvars (car args) ss is ts star inls)))
-;; 	 (vars (mapcar 'car vs))
-;; 	 (forms (mapcar 'cdr vs))
-;; 	 (vnames (mapcar 'var-name vars))
-;; 	 (*vars* (if star *vars* (append vars *vars*))))
-
-;;     (c1add-globals (set-difference ss vnames))
-;;     (check-vdecl vnames ts is)
-;;     (setq body (c1decl-body other-decls body))
-
-;;     (unless (single-type-p (info-type (cadr body))) 
-;;       (let ((mv (car (member-if 'is-mv-var vars))))
-;; 	(when mv
-;; 	  (ref-vars (c1var (var-name mv)) (list mv)))))
-
-;;     (ref-vars body vars)
-
-;;     (dolist (var vars) (setf (var-type var) (var-mt var)));FIXME?
- 
-;;     (let* ((*vars* ov))
-;;       (under-env
-;;        env
-;;        (let* ((z (trim-vars vars forms body star))
-;; 	      (vars (pop z))
-;; 	      (fms (pop z))
-;; 	      (body (car z)))
-	 
-;; 	 (dolist (fm fms) (add-info info (cadr fm)))
-;; 	 (add-info info (cadr body))
-	 
-;; 	 (setf (info-type info) (info-type (cadr body)))
-;; 	 (unless (eq setjmps *setjmps*) (setf (info-volatile info) 1))
-	 
-;; 	 (if vars (list nm info vars fms body) 
-;; 	   (list* (car body) info (cddr body))))))))
-
-;; (defun c1let-* (args &optional star 
-;; 		     &aux (nm (if star 'let* 'let))
-;; 		     (ov *vars*) (*vars* *vars*) (setjmps *setjmps*)
-;; 		     ss is ts body other-decls
-;; 		     (info (make-info)))
-
-;;   (when (endp args) (too-few-args nm 1 0))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cdr args) nil))
-
-;;   (let* ((vs (nreverse (mvars (car args) ss is ts info star)))
-;; 	 (vars (mapcar 'car vs))
-;; 	 (forms (mapcar 'cdr vs))
-;; 	 (vnames (mapcar 'var-name vars))
-;; 	 (*vars* (if star *vars* (append vars *vars*))))
-
-;;     (c1add-globals (set-difference ss vnames))
-;;     (check-vdecl vnames ts is)
-;;     (setq body (c1decl-body other-decls body))
-
-;;     (when (member-if 'is-mv-var vars) 
-;;       (unless (single-type-p (info-type (cadr body))) 
-;; 	(c1vref +mv+)))
-
-;;     (dolist (var vars) 
-;;       (check-vref var)
-;;       (setf (var-type var) (var-mt var)));FIXME?
-  
-;;     (let* ((*vars* ov)
-;; 	   (z (trim-vars vars forms body star))) ;FIXME mi5 too
-;;       (add-info info (cadr body))
-;;       (setf (info-type info) (info-type (cadr body)))
-;;       (unless (eq setjmps *setjmps*) (setf (info-volatile info) 1))
-;;       (if (car z) (list* nm info z) (caddr z)))))
-
 (defun c1let (args)
   (c1let-* args))
 (defun c1let* (args)
   (c1let-* args t))
 
-;; (defun c1let (args &aux (info (make-info))(setjmps *setjmps*)
-;;                         (forms nil) (vars nil) (vnames nil)
-;;                         ss is ts body other-decls
-;;                         (*vars* *vars*))
-;;   (when (endp args) (too-few-args 'let 1 0))
-
-;; ;  (setq args (declare-let-bindings-new args nil ss))
-;; ;  (setq args (declare-let-bindings-new1 args nil ss))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cdr args) nil))
-
-;; ;  (c1add-globals ss)
-
-;;   (let ((*vars* *vars*))
-;;     (dolist** (x (car args))
-;;     (cond ((symbolp x)
-;;            (let ((v (c1make-var x ss is ts)))
-;;                 (push x vnames)
-;;                 (push v vars)
-;;                 (set-var-init-type (car vars) #tnull)
-;; 		(push (default-init (var-type v)) forms)))
-;;           (t (cmpck (not (and (consp x) (or (endp (cdr x)) (endp (cddr x)))))
-;;                     "The variable binding ~s is illegal." x)
-;;              (let ((v (c1make-var (car x) ss is ts)))
-;; 	       (push (car x) vnames)
-;; 	       (push v vars)
-;; 	       (push (if (endp (cdr x))
-;; 			 (default-init (var-type v))
-;; 		       (and-form-type (var-type v)
-;; 				      (c1expr* (cadr x) info)
-;; 				      (cadr x)))
-;; 		     forms)
-
-;; 	       (when (eq (caar forms) 'var)
-;; 		 (pushnew (caaddr (car forms)) (var-aliases (car vars))))
-
-;; 	       (set-var-init-type (car vars) (info-type (second (car forms))))
-;; 	       (maybe-reverse-type-prop (var-type v) (car forms))))))
-
-;;     (c1add-globals (set-difference ss vnames))
-    
-;;     (setq vars (nreverse vars))
-;;     (dolist* (v vars) (push v *vars*))
-;;     (setq vars (nreverse vars))
-    
-;;     (check-vdecl vnames ts is)
-    
-;;     (setq body (c1decl-body other-decls body)))
-
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (dolist** (var vars) (check-vref var))
-
-;;   (or (eql setjmps *setjmps*) (setf (info-volatile info) 1))
-
-;;   (dolist (var vars) (setf (var-type var) (var-mt var)))
-  
-;;   (let ((z (trim-vars vars forms body)))
-;;     (cond ((car z) (list* 'let info z))
-;; 	  ((caddr z)))))
 
 (defun c2let (vars forms body
                    &aux block-p bindings initials
@@ -610,61 +380,6 @@
   (c2expr body)
   (when block-p (wt "}")))
 
-;; (defun c1let* (args &aux forms vars vnames (*inline-forms* *inline-forms*) 
-;; 		    (setjmps *setjmps*)
-;;                     ss is ts body other-decls
-;;                     (info (make-info)))
-;;   (when (endp args) (too-few-args 'let* 1 0))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cdr args) nil))
-;; ;  (c1add-globals ss)
-
-;;   (let ((*vars* *vars*))
-;;     (dolist (x (car args))
-;;       (cond ((symbolp x)
-;; 	     (let ((v (c1make-var x ss is ts)))
-;; 	       (push x vnames)
-;; 	       (push (default-init (var-type v)) forms)
-;; 	       (push v vars)
-;; 	       (set-var-init-type (car vars) #tnull)
-;; 	       (push v *vars*)))
-;; 	    ((not (and (consp x) (or (endp (cdr x)) (endp (cddr x)))))
-;; 	     (cmperr "The variable binding ~s is illegal." x))
-;; 	    (t (let ((v (c1make-var (car x) ss is ts)))
-;; 		 (push (car x) vnames)
-;; 		 (push (if (endp (cdr x))
-;; 			   (default-init (var-type v))
-;; 			 (if (and *inline-forms* (eq (caar *inline-forms*) (cadr x)))
-;; 			     (let ((n (cdr (pop *inline-forms*))))
-;; 			       (add-info info (cadr n))
-;; 			       n)
-;; 			   (and-form-type (var-type v)
-;; 					  (c1expr* (cadr x) info)
-;; 					  (cadr x))))
-;; 		       forms)
-;; 		 (push v vars)
-;; 		 (when (eq (caar forms) 'var)
-;; 		   (pushnew (caaddr (car forms)) (var-aliases (car vars))))
-;; 		 (set-var-init-type (car vars) (info-type (second  (car forms))))
-;; 		 (maybe-reverse-type-prop (var-type v) (car forms))
-;; 		 (push v *vars*)))))
-;;     (c1add-globals (set-difference ss vnames))
-;; 					;    (when *inline-forms* (print args)(break))
-;;     (check-vdecl vnames ts is)
-;;     (setq body (c1decl-body other-decls body))
-;;     (when (member-if 'is-mv-var vars) 
-;;       (unless (single-type-p (info-type (cadr body))) 
-;; 	(c1vref +mv+))))
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-;;   (dolist (var vars) (check-vref var))
-;;   (or (eql setjmps *setjmps*) (setf (info-volatile info) 1))
-;;   (dolist (var vars) (setf (var-type var) (var-mt var)))
-
-;;   (let ((z (trim-vars vars forms body t)))
-;;     (cond ((car z) (list* 'let* info z))
-;; 	  ((caddr z)))))
-
 (defun c2let* (vars forms body
                     &aux (block-p nil)
                     (*unwind-exit* *unwind-exit*)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmploc.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmploc.lsp
@@ -212,7 +212,7 @@
 	 (when (and *values-to-go* *mv-var*) 
 	   (wt "register object *_x=vs_base+1,"
 	       "*_y=(object *)V" (var-loc *mv-var*) ";"
-	       "if (!_y) vs_top=base; else if (vs_top<_x) vs_top=_y-1; else {for(;_x<vs_top;) *_y++=*_x++;vs_top=_y;}")
+	       "if (!_y) vs_top=base; else {for(;_x<vs_top;) *_y++=*_x++;if (_x>vs_top) _y--;vs_top=_y;}")
 	   (base-used)
 	   (unless (boundp '*extend-vs-top*) (baboon))
 	   (setq *extend-vs-top* t *values-to-go* nil))
@@ -475,7 +475,7 @@
 	 (ft   (loc-kind loc))
 	 (tt   (get key 'cmp-lisp-type))
 	 (cast (if (member key '(:cnum :creal)) "" (strcat "(" key ")")))
-	 (pp   (search "*" cast)))
+	 (pp   (find #\* cast)))
 
     (cond ((unless fvt (eq ft tt)))
 	  ((equal ft #tt)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpmulti.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpmulti.lsp
@@ -217,18 +217,11 @@
   (wt-nl "vs_base=V" base ";vs_top=V" top ";sup=V" sup ";}")
   (unwind-exit 'fun-val nil (if top-data (car top-data))))
 
-(defun c1values (args &aux (nargs (mapcar (lambda (x &aux (x (c1expr x)))
-					    (setf (info-type (cadr x)) (coerce-to-one-value (info-type (cadr x))))
-					    x) args)))
-  (cond ((unless (cdr nargs) (car nargs)))
-	((let ((info (make-info)))
-	   (setf (info-type info)
-		 (cons 'returns-exactly
-		       (mapcar (lambda (x &aux (i (cadr x)))
-				 (add-info info i)
-				 (info-type i))
-			       nargs)))
-	   (list 'values info nargs)))))
+(defun c1values (args &aux (info (make-info))(a (mapcar (lambda (x) (c1expr* x info)) args)))
+  (setf (info-type info)
+	(let ((x (mapcar (lambda (x) (coerce-to-one-value (info-type (cadr x)))) a)))
+	  (if (unless (cdr x) x) (car x) (cons 'returns-exactly x))));FIXME
+  (list 'values info a))
 
 ;; (defun c1values (args &aux (info (make-info)))
 ;;       (cond ((and args (not (cdr args)))
@@ -360,13 +353,15 @@
 
   (setq vars (nreverse vars))
   (let* ((tp (info-type (second init-form)))
+	 (tp (if (cmpt tp) (unless (member nil tp) tp) tp));FIXME
+	 (def (when tp #tnull))
 	 (tp (cond ((not tp) tp)
 		   ((single-type-p tp) (list tp))
 		   ((eq tp '*) (make-list (length vars) :initial-element t))
 		   ((cdr tp)))))
     (do ((v vars (cdr v)) (t1 tp (cdr t1)))
 	((not v))
-	(set-var-init-type (car v) (or (car t1) #tnull))))
+	(set-var-init-type (car v) (if t1 (car t1) def))))
 
   (dolist (v vars) (push-var v init-form))
 
@@ -386,143 +381,6 @@
 
   (list 'multiple-value-bind info vars init-form body))
 
-;; (defun c1multiple-value-bind (args &aux (info (make-info))
-;;                                    (vars nil) (vnames nil) init-form
-;;                                    ss is ts body other-decls
-;;                                    (*vars* *vars*))
-;;   (when (or (endp args) (endp (cdr args)))
-;;     (too-few-args 'multiple-value-bind 2 (length args)))
-
-;;   (when (and (caar args) (not (cdar args)))
-;;     (return-from c1multiple-value-bind
-;; 		 (c1expr `(let ((,(caar args) ,(cadr args))) ,@(cddr args)))))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cddr args) nil))
-
-;;   (dolist (s (car args))
-;;     (let ((v (c1make-var s ss is ts)))
-;;       (push s vnames)
-;;       (push v vars)))
-
-;;   (c1add-globals (set-difference ss vnames))
-
-;;   (setq init-form (c1arg (cadr args) info))
-
-;;   (setq vars (nreverse vars))
-;;   (let* ((tp (info-type (second init-form)))
-;; 	 (tp (cond ((not tp) tp)
-;; 		   ((single-type-p tp) (list tp))
-;; 		   ((eq tp '*) (make-list (length vars) :initial-element t))
-;; 		   ((cdr tp)))))
-;;     (do ((v vars (cdr v)) (t1 tp (cdr t1)))
-;; 	((not v))
-;; 	(set-var-init-type (car v) (or (car t1) #tnull))))
-
-;;   (dolist* (v vars) (push v *vars*))
-
-;;   (check-vdecl vnames ts is)
-
-;;   (setq body (c1decl-body other-decls body))
-
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (ref-vars body vars)
-;;   (dolist** (var vars) (check-vref var))
-
-;;   (list 'multiple-value-bind info vars init-form body))
-
-;; (defun c1multiple-value-bind (args &aux (info (make-info))
-;;                                    (vars nil) (vnames nil) init-form
-;;                                    ss is ts body other-decls
-;;                                    (*vars* *vars*))
-;;   (when (or (endp args) (endp (cdr args)))
-;;     (too-few-args 'multiple-value-bind 2 (length args)))
-
-;;   (when (and (caar args) (not (cdar args)))
-;;     (return-from c1multiple-value-bind
-;; 		 (c1expr `(let ((,(caar args) ,(cadr args))) ,@(cddr args)))))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cddr args) nil))
-
-;;   (dolist (s (car args))
-;;     (let ((v (c1make-var s ss is ts)))
-;;       (push s vnames)
-;;       (push v vars)))
-
-;;   (c1add-globals (set-difference ss vnames))
-
-;;   (let (*c1exit*) (setq init-form (c1expr* (cadr args) info)))
-
-;;   (setq vars (nreverse vars))
-;;   (let* ((tp (info-type (second init-form)))
-;; 	 (tp (cond ((not tp) tp)
-;; 		   ((single-type-p tp) (list tp))
-;; 		   ((eq tp '*) (make-list (length vars) :initial-element t))
-;; 		   ((cdr tp)))))
-;;     (do ((v vars (cdr v)) (t1 tp (cdr t1)))
-;; 	((not v))
-;; 	(set-var-init-type (car v) (or (car t1) #tnull))))
-
-;;   (dolist* (v vars) (push v *vars*))
-
-;;   (check-vdecl vnames ts is)
-
-;;   (setq body (c1decl-body other-decls body))
-
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (ref-vars body vars)
-;;   (dolist** (var vars) (check-vref var))
-
-;;   (list 'multiple-value-bind info vars init-form body))
-
-;; (defun c1multiple-value-bind (args &aux (info (make-info))
-;;                                    (vars nil) (vnames nil) init-form
-;;                                    ss is ts body other-decls
-;;                                    (*vars* *vars*))
-;;   (when (or (endp args) (endp (cdr args)))
-;;     (too-few-args 'multiple-value-bind 2 (length args)))
-
-;;   (when (and (caar args) (not (cdar args)))
-;;     (return-from c1multiple-value-bind
-;; 		 (c1expr `(let ((,(caar args) ,(cadr args))) ,@(cddr args)))))
-
-;;   (multiple-value-setq (body ss ts is other-decls) (c1body (cddr args) nil))
-
-;;   (dolist (s (car args))
-;;     (let ((v (c1make-var s ss is ts)))
-;;       (push s vnames)
-;;       (push v vars)))
-
-;;   (c1add-globals (set-difference ss vnames))
-
-;;   (let (*c1exit*) (setq init-form (c1expr* (cadr args) info)))
-
-;;   (setq vars (nreverse vars))
-;;   (let* ((tp (info-type (second init-form)))
-;; 	 (tp (cond ((not tp) tp)
-;; 		   ((single-type-p tp) (list tp))
-;; 		   ((eq tp '*) (make-list (length vars) :initial-element t))
-;; 		   ((cdr tp)))))
-;;     (do ((v vars (cdr v)) (t1 tp (cdr t1)))
-;; 	((not v))
-;; 	(set-var-init-type (car v) (or (car t1) #tnull))))
-
-;;   (dolist* (v vars) (push v *vars*))
-
-;;   (check-vdecl vnames ts is)
-
-;;   (setq body (c1decl-body other-decls body))
-
-;;   (add-info info (cadr body))
-;;   (setf (info-type info) (info-type (cadr body)))
-
-;;   (dolist** (var vars) (check-vref var))
-
-;;   (list 'multiple-value-bind info vars init-form body))
-
 (defun max-stack-space (form) (abs (vald (info-type (cadr form)))))
 
 (defun stack-space (form)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpopt.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpopt.lsp
@@ -609,24 +609,6 @@
 	 "@01;({fixnum _t=(#0)/(#1);_t=((#0)<=0 && (#1)>=0) || ((#0)>=0 && (#1)<=0) || ((#1)*_t==(#0)) ? _t : _t+1;@1((#0)-_t*(#1))@ _t;})")
    (get 'ceiling 'inline-always))
 
-;;SI::POWM
- (push '((t t t) t #.(flags)"powm_bbb(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((fixnum t t) t #.(flags)"powm_fbb(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((t fixnum t) t #.(flags)"powm_bfb(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((t t fixnum) t #.(flags)"powm_bbf(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((fixnum fixnum t) t #.(flags)"powm_ffb(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((fixnum t fixnum) t #.(flags)"powm_fbf(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((t fixnum fixnum) t #.(flags)"powm_bff(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
- (push '((fixnum fixnum fixnum) t #.(flags)"powm_fff(#0,#1,#2)")
-   (get 'si::powm 'inline-unsafe))
-
 ;;FOURTH
 ;;  (push '((t) t #.(flags)"cadddr(#0)")
 ;;    (get 'fourth 'inline-safe))
@@ -704,49 +686,11 @@
    (get 'length 'inline-always))
 
 ;;LIST
- (push '(nil t #.(flags)"Cnil")
-   (get 'list 'inline-always))
-(push '((t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t t t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t t t t t t) t #.(flags ans)LIST-INLINE)
-   (get 'list 'inline-always))
-(push '((t t t t t t t t t t) t #.(flags ans)LIST-INLINE)
+(push '((t *) list #.(flags ans rfa) LIST-INLINE);proper-list can get bumped
    (get 'list 'inline-always))
 
 ;;LIST*
- (push '((t) t #.(flags)"(#0)")
-   (get 'list* 'inline-always))
-(push '((t t) t #.(flags ans)"make_cons(#0,#1)")
-   (get 'list* 'inline-always))
-(push '((t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t t t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t t t t t t) t #.(flags ans)LIST*-INLINE)
-   (get 'list* 'inline-always))
-(push '((t t t t t t t t t t) t #.(flags ans)LIST*-INLINE)
+(push '((t *) list #.(flags ans rfa) LIST*-INLINE)
    (get 'list* 'inline-always))
 
 ;;CONS
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpspecial.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpspecial.lsp
@@ -56,8 +56,7 @@
     (too-many-args 'the 2 (length args)))
   (setq form (c1expr (cadr args)))
   (setq info (copy-info (cadr form)))
-  (setq dtype (max-vtp (car args)))
-  (when *compiler-new-safety* (setq dtype t))
+  (setq dtype (cmp-norm-tp (cadr (si::ftype-to-sig (list nil (car args))))))
   (when (exit-to-fmla-p) (setq dtype (type-or1 (when (type-and #tnull dtype) #tnull) (when (type-and #t(not null) dtype) #ttrue))));FIXME
   (when (equal dtype #tboolean)
     (unless (type>= dtype (info-type info))
@@ -327,11 +326,14 @@
 ;;   (push a (car (fn-env f)))
 ;;   f)
 
-(defun mf (id)
+(defun mf (id &optional fun)
   (let* ((f (mc)))
 ;    (when (consp id) (setf (caddr (si::call f)) (compress-fle id nil nil)))
+    (when fun
+      (afe (cons 'fun fun) f))
     (afe (cons 'id id) f)
-    (afe (cons 'df (current-env)) f)
+    (when (or fun (consp id))
+      (afe (cons 'df (current-env)) f))
     f))
 
 ;; (defun fn-get (fn prop)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptop.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptop.lsp
@@ -722,7 +722,7 @@
 	    (rc (pop oc))
 	    ;FIXME check-type must refer to top regular variable binding, but must be beneath argument number logic
 	    (oc (append (when s rc) (car oc)))
-	    (rc (mapcar (lambda (x) `(declare (,@(when s `(hint)) ,(caddr x) ,(cadr x)))) rc))
+	    (rc (mapcan (lambda (x) (when (eq (car x) 'check-type) `((declare (,@(when s `(hint)) ,(caddr x) ,(cadr x)))))) rc))
 	    (rc (cons `(declare (optimize (safety ,dl))) rc))
 	    (narg (when opts +nargs+));FIXME (cdr opts)
 	    (nr (length regs))
@@ -967,7 +967,7 @@
 				  (unless (stringp x) (list (c1arg (cons 'ub x) info))))
 				args)))
 	    (when (eq tp :opaque) (baboon))
-	    (when (search "=" inl)
+	    (when (find #\= inl)
 	      (setf (info-flags info) (logior (iflags side-effects) (info-flags info))))
 	    (list 'lit info (info-type info) inl nargs (make-vs info))))))
 
@@ -999,12 +999,6 @@
   (let ((a (member '&aux ll)))
     (ldiff ll a)))
 
-(defun suppress-unfinalized-local-fun-warnings (name b l)
-  (let ((fun (local-fun-p name)))
-    (when fun
-      (member-if (lambda (x) (when (fun-p x) (unless (eq x fun) (not (consp (if (eq b 'cb) (fun-c1cb x) (fun-c1 x)))))))
-		 (append (info-ref (cadr l)) (info-ref-ccb (cadr l)))))))
-
 (defun do-l1-fun (name src e b &aux (wns *warning-note-stack*) (*recursion-detected* (cons (list name) *recursion-detected*)))
 
   (let* ((l (c1lambda-expr src))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptype.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptype.lsp
@@ -296,9 +296,10 @@
 
 (defun get-inf (x)
   (etypecase
-   x
-   (rational (if (plusp x) '+rinf (if (minusp x) '-rinf 'rnan)))
-   (float (float (if (plusp x) +inf (if (minusp x) -inf nan)) x))))
+      x
+    (integer (if (plusp x) '+iinf (if (minusp x) '-iinf 'inan)))
+    (rational (if (plusp x) '+rinf (if (minusp x) '-rinf 'rnan)))
+    (float (float (if (plusp x) +inf (if (minusp x) -inf nan)) x))))
 
 (defun pole-type (y)
   (etypecase
@@ -310,7 +311,8 @@
 
 (defun tp-to-inf (tp x)
   (ecase tp
-	 ((integer ratio) (if x '-rinf '+rinf))
+	 (integer (if x '-iinf '+iinf))
+	 (ratio (if x '-rinf '+rinf))
 	 (short-float (if x -sinf +sinf))
 	 (long-float (if x -inf +inf))))
 
@@ -324,15 +326,18 @@
 
 
 (defun bound-num (x)
-  (cond ((eq x '+rinf) +sinf)
-	((eq x '-rinf) -sinf)
-	((eq x '+rnan) snan)
+  (cond ((member x '(+iinf +rinf)) +sinf)
+	((member x '(-iinf -rinf)) -sinf)
+	((member x '(inan rnan)) snan)
 	((consp x) (cadr x))
 	(x)))
 	
 (defun rat-bound-p (x)
-  (or (member x '(+rinf -rinf rnan))
+  (or (member x '(+iinf -iinf inan +rinf -rinf rnan))
       (rationalp (if (consp x) (cadr x) x))))
+(defun int-bound-p (x)
+  (or (member x '(+iinf -iinf inan))
+      (integerp (if (consp x) (cadr x) x))))
 
 
 ;; (& ^ \| ~)
@@ -344,17 +349,18 @@
 ;; (ash >> << integer-length clzl ctzl abs )
 
 
-(defun ?rationalize (x f r)
-  (cond ((not (member f '(+ - * max min si::number-plus si::number-times si::number-minus pexpt /-pole))) x);closed functions over rationals
+(defun ?rationalize (x f r &aux (z (or (eq f '/-pole) (member-if-not 'int-bound-p r))))
+  (cond ((not (member f '(+ - * max min si::number-plus si::number-times si::number-minus pexpt /-pole))) x);closed functions over rationals plus pexpt
 	((member-if-not 'rat-bound-p r) x)
-	((isinf x) (if (> x 0) '+rinf '-rinf))
-	((isnan x) 'rnan)
+	((unless (int-bound-p (cadr r)) (eq f 'pexpt)) x)
+	((isinf x) (if (plusp x) (if z '+rinf '+iinf) (if z '-rinf '-iinf)))
+	((isnan x) (if z 'rnan 'inan))
 	((numberp x) (rational x))
 	(x)))
 
 (defun ?list-bound (x r)
   (if (when (and (numberp x) (member-if 'consp r))
-	(not (or (isinf x) (isnan x) (integerp x))))
+	(not (or (isinf x) (isnan x))))
       (list x)
       x))
 
@@ -362,35 +368,51 @@
   (if (consp x) (car x) 0))
 
 (defun pole-check (f r)
-  (apply f (if (when (symbolp f) (get f 'pole)) r (mapcar 'bound-num r))))
+  (si::break-on-floating-point-exceptions :suspend t)
+  (prog1
+      (apply f (if (when (symbolp f) (get f 'pole)) r (mapcar 'bound-num r)))
+    (si::break-on-floating-point-exceptions :suspend nil)))
+
 
 (defun mfc1 (f &rest r)
   (?list-bound (?rationalize (pole-check f r) f r) r))
 
 (defun infp (x m)
-  (or (eq x (if m '-rinf '+rinf)) (eql x (if m -inf +inf)) (eql x (if m -sinf +sinf))))
+  (member x (if m `(-iinf -rinf ,-sinf ,-inf) `(+iinf +rinf ,+sinf ,+inf))))
 
 (defun nanp (x)
-  (or (eq x 'rnan) (isnan x)))
+  (or (member x '(inan rnan)) (isnan x)))
 
 (defun minmax1 (tp m)
-  (reduce (lambda (y x &aux (x (if (when (consp x) (eq (cdr x) 'incl)) (car x) x)))
+  (or
+   (reduce (lambda (y x &aux (x (if (when (consp x) (eq (cdr x) 'incl)) (car x) x)))
 	    (cond ((eq y '*) y)
 		  ((infp x m) '*)
-		  ((infp x (not m)) y)
-		  ((nanp x) '*)
+		  ((infp x (not m)) (or y 0))
+		  ((nanp x) y);'*
 		  ((not y) x)
 		  ((funcall (if m '< '>) (if (consp x) (car x) x) (if (consp y) (car y) y)) x)
 		  ((when (atom x) (when (consp y) (eql x (car y)))) x)
 		  (y)))
-	  tp :initial-value nil))
+	   tp :initial-value nil)
+   '*))
+
+(defun inf-tp (x)
+  (case x
+    ((+iinf -iinf inan) 'integer)
+    ((+rinf -rinf rnan) 'ratio)))
+
+(defun mk-tp2 (tp &aux (mm1 (minmax1 tp t)) (mm2 (minmax1 tp nil)))
+  (reduce
+   'type-or1
+   (mapcar (lambda (x)
+	     (when (member-if (lambda (y &aux (y (if (listp y) (if (integerp (car y)) 1/2 (car y)) y)))
+				(or (typep y x) (eq (inf-tp y) x)))
+			      tp)
+	       (cmp-norm-tp `(,(if (eq x 'ratio) 'rational x) ,mm1 ,mm2))))
+	   si::+range-types+)
+   :initial-value nil))
 
-(defun mk-tp1 (e tp)
-  (cmp-norm-tp
-   `(,(let* ((x (car (member e si::+range-types+ :test 'typep))))
-	(case x (ratio 'rational)(otherwise x)))
-     ,(minmax1 tp t)
-     ,(minmax1 tp nil))))
 
 (defun outer-merge (&rest r &aux (z (pop r)))
   (mapcan (lambda (z)
@@ -417,8 +439,7 @@
 	  (vr (set-difference v vc)))
      (reduce 'type-or1
 	     (mapcar 'complex-contagion vc)
-	     :initial-value
-	     (when vr (mk-tp1 (mk-contagion-rep f nil r) vr))))
+	     :initial-value  (mk-tp2 vr)))
    (complex-contagion (mk-contagion-rep f t r))))
 
 (defun super-range (f &rest r)
@@ -474,13 +495,11 @@
 		   z))))
 
 
-(defun complex-contagion (z)
-  (car (member (object-tp z)
-	       '(#t(complex integer)
-		 #t(complex rational)
-		 #t(complex short-float)
-		 #t(complex long-float)
-		 #tcomplex) :test 'type<=)))
+(defun complex-contagion (z &aux (z (if (listp z) (car z) z)))
+  (cadar (member z
+		 '#.(mapcar (lambda (x &aux (x `(complex ,x))) (list x (cmp-norm-tp x)))
+			   '(integer rational short-float long-float real))
+		 :test 'typep :key 'car)))
 
 (defun mfc-complexp (x &aux (x (if (listp x) (car x) x)))
   (complexp x))
@@ -504,10 +523,8 @@
     (super-range f t1)))
 (si::putprop 'atan 'atan-propagator 'type-propagator)
 
-(defun float-propagator (f t1 &optional (t2 #tnull))
-  (if (equal t2 #tnull)
-      (super-range f (type-and #treal t1))
-    (super-range f (type-and #treal t1) (type-and #tfloat t2))))
+(defun float-propagator (f t1 &optional t2)
+  (super-range f (type-and #treal t1) (or t2 (type-and #tfloat t1) #t(member 0.0))))
 (setf (get 'float 'type-propagator) 'float-propagator)
 
 (defun bit-type (tp)
@@ -775,11 +792,21 @@
 	(#tcons)))
 (si::putprop 'cons 'cons-propagator 'type-propagator)
 
-(defun co1carcdr (f x)
-  (let* ((tp (car (atomic-tp (info-type (cadr (with-restore-vars (c1arg (car x))))))));FIXME ignorable-form
+(defun carcdr-c1form-narg (fm)
+  (case (car fm)
+    (inline (carcdr-c1form-narg (fourth fm)))
+    (let* (carcdr-c1form-narg (fifth fm)))
+    (lit (carcdr-c1form-narg (car (fifth fm))))
+    (ub (fourth fm))))
+
+(defun co1carcdr (f x);FIXME c1 prop?
+  (let* ((c1form (mi1 f x))
+	 (narg (carcdr-c1form-narg c1form))
+	 (tp (when (and narg (ignorable-form narg)) (car (atomic-tp (info-type (cadr narg))))))
 	 (tp (when (consp tp) (funcall f tp)))
 	 (tp (get-var tp)))
-    (when tp (c1var tp))))
+    (if tp (c1var tp) c1form)))
+
 
 (setf (get 'car 'co1) 'co1carcdr)
 (setf (get 'cdr 'co1) 'co1carcdr)
@@ -845,8 +872,8 @@
 			   &aux (t1 (type-and #treal t1))(t2 (type-and #treal t2))
 			   (i (member f '(floor truncate round ceiling))))
   (let* ((sr (super-range (lambda (x)
-			    (cond ((isinf x) (if i (if (> x 0) '+rinf '-rinf) x))
-				  ((isnan x) (if i 'rnan x))
+			    (cond ((isinf x) (if i (if (> x 0) '+iinf '-iinf) x))
+				  ((isnan x) (if i 'inan x))
 				  ((funcall f x))))
 			  (/-propagator '/ t1 t2)))
 	 (sr (if i (type-and #tinteger sr) sr)))
@@ -889,7 +916,7 @@
   (typecase
    y
    ((real 0 0) (1+ y))
-   ((integer 1000) '+rinf)
+   ((integer 1000) (get-inf x))
    (otherwise (expt x y))))
 
 (defun expt-propagator (f t1 t2)
@@ -1108,18 +1135,21 @@
 	       (structure (si::s-data-print-function (c-structure-def x)))
 	       (t t))))
     (when (consp tp)
-      (if (cmpt tp)
-	  (mapcan 'kingdoms-with-unprintable-individuals (cdr tp))
-	  (mapcan (lambda (x)
-		    (when (member-if (lambda (x) (f x)) (cdr x));FIXME #'f
-		      (list (car x))))
-		  (caaddr tp))))))
-
+      (mapcan (lambda (x)
+		(when (member-if (lambda (x) (f x)) (cdr x));FIXME #'f
+		  (list (car x))))
+	      (caaddr tp)))))
 
-(defun export-type (type)
+(defun export-type1 (type)
   (let ((x (kingdoms-with-unprintable-individuals type)))
     (if x (type-or1 type (cmp-norm-tp (cons 'or x))) type)))
 
+(defun export-type (type)
+  (if (cmpt type)
+      (cons (pop type) (mapcar 'export-type1 type))
+    (export-type1 type)))
+
+
 (defun bump-tp (tp)
   (cond ((eq tp '*) tp)
 	((and (consp tp) (member (car tp) '(values returns-exactly)))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmputil.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmputil.lsp
@@ -238,11 +238,6 @@
                  si::*break-hidden-packages*)))
          (si:error-set form)))
 
-(dolist (v '(si::cdefn inline-safe inline-unsafe
-		       inline-always c1conditional c2 c1 c1+ co1
-		       si::structure-access co1special
-		       top-level-macro t3 t2 t1))
-	   (si::putprop v t 'compiler-prop ))
 
 (defun  compiler-def-hook (symbol code) symbol code nil)
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpvar.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpvar.lsp
@@ -653,6 +653,9 @@
 	  (cmpwarn "Setting form type ~s to orthogonal type ~s"
 		   (cmp-unnorm-tp it) (cmp-unnorm-tp type))
 	  (setq nt type))
+	(when (or (eq form (c1nil)) (eq form (c1t)));FIXME
+	  (unless (type= it nt)
+	    (return-from sft nil)))
 	(setf (info-type (cadr form)) nt)
 	(unless no-recur
 	  (case (car form)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpwt.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpwt.lsp
@@ -152,20 +152,23 @@
 (defvar *fasd-data*)
 
 (defvar *hash-eq* nil)
-(defvar *run-hash-equal-data-checking* t)
+(defvar *run-hash-equal-data-checking* nil)
 (defun memoized-hash-equal (x depth);FIXME implement all this in lisp
-  (declare (fixnum depth))
-  (when *run-hash-equal-data-checking*
-    (unless *hash-eq* (setq *hash-eq* (make-hash-table :test 'eq)))
-    (or (gethash x *hash-eq*)
-	(setf (gethash x *hash-eq*)
+  (declare (fixnum depth)(inline si::hash-set))
+  (unless *run-hash-equal-data-checking*
+    (return-from memoized-hash-equal 0))
+  (unless *hash-eq* (setq *hash-eq* (make-hash-table :test 'eq)))
+  (address
+   (or (gethash x *hash-eq*)
+       (setf (gethash x *hash-eq*)
+	     (nani
 	      (if (> depth 3) 0
-		(if (typep x 'cons)
-		    (logxor (setq depth (the fixnum (1+ depth)));FIXME?
-			    (logxor
-			     (memoized-hash-equal (car x) depth)
-			     (memoized-hash-equal (cdr x) depth)))
-		  (si::hash-equal x depth)))))))
+		  (if (typep x 'cons)
+		      (logxor (setq depth (the fixnum (1+ depth)));FIXME?
+			      (logxor
+			       (memoized-hash-equal (car x) depth)
+			       (memoized-hash-equal (cdr x) depth)))
+		      (si::hash-equal x depth))))))))
 
 (defun push-data-incf (x)
   (declare (ignore x));FIXME
@@ -223,9 +226,6 @@
   (cond (*compiler-compile*;FIXME, clean this up
 	 (setq *compiler-compile-data* (mapcar 'verify-datum (nreverse *data*)))
 	 (wt-data2 `(mapc 'eval *compiler-compile-data*)))
-	(*fasd-data*
-	 (dolist (v (nreverse *data*))
-	   (wt-data2 (verify-datum v))))
 	((wt-data2 `(progn ,@(mapcar 'verify-datum (nreverse *data*))))))
   (when *fasd-data*
     (si::close-fasd (car *fasd-data*))))
--- gcl27-2.7.0.orig/cmpnew/gcl_collectfn.lsp
+++ gcl27-2.7.0/cmpnew/gcl_collectfn.lsp
@@ -15,7 +15,7 @@
 ;; collected.
 
 (in-package :compiler)
-(import 'sloop::sloop)
+;(import 'sloop::sloop)
 
 (defstruct fn
   name           ;; name of THIS FUNCTION
@@ -65,6 +65,7 @@
   )
 
 (defun emit-fn (flag)
+  (declare (ignore flag))
 ;  (setq *record-call-info* flag)
   )
 
@@ -100,7 +101,7 @@
 	(t *other-form*)))
 
 (defun who-calls (f)
-  (sloop for (ke val) in-table *call-table*
+  (sloop::sloop for (ke val) in-table *call-table*
 	 when (or (member f (fn-callees val))
 		  (member f (fn-macros val)))
 	 collect ke))
@@ -230,6 +231,7 @@
       ))
 
 (defun make-all-proclaims (&rest files)
+  (declare (ignore files))
   ;; (setup-sys-proclaims)
   ;; (dolist (v files)
   ;; 	  (mapcar 'load (directory v)))
@@ -291,7 +293,7 @@
 (defun list-undefined-functions (&aux undefs)
   (sloop::sloop for (name fn) in-table *call-table*
 		declare (ignore name)
-		do (sloop for w in (fn-callees fn)
+		do (sloop::sloop for w in (fn-callees fn)
 			  when (not (or (fboundp w)
 					(gethash w *call-table*)
 					(get w 'inline-always)
--- gcl27-2.7.0.orig/cmpnew/gcl_lfun_list.lsp
+++ gcl27-2.7.0/cmpnew/gcl_lfun_list.lsp
@@ -16,6 +16,8 @@
 ;	     (((list) t) . si::cons-car)
 ;	     (((list) t) . si::cons-cdr)
 	     (((t t) cons) . cons)
+	     (((*) si::proper-list) . list)
+	     (((t *) list) . list*)
 	     (((fixnum) t) . si::nani)
 	     (((t) fixnum) . si::address);FIXME
 ;	     (((integer) fixnum) . si::mpz_bitlength)
--- gcl27-2.7.0.orig/git.tag
+++ gcl27-2.7.0/git.tag
@@ -1,2 +1,2 @@
-"Version_2_7_0pre27"
+"Version_2_7_0pre29"
 
--- gcl27-2.7.0.orig/lsp/gcl_bit.lsp
+++ gcl27-2.7.0/lsp/gcl_bit.lsp
@@ -135,7 +135,9 @@
   (declare (optimize (safety 1))(dynamic-extent r))
   (check-type x (array bit))
   (apply 'aset v x r))
+(setf (get 'baset 'compiler::cmp-inline) t)
 (defun sbaset (v x &rest r)
   (declare (optimize (safety 1))(dynamic-extent r))
   (check-type x (simple-array bit))
   (apply 'aset v x r))
+(setf (get 'sbaset 'compiler::cmp-inline) t)
--- gcl27-2.7.0.orig/lsp/gcl_defmacro.lsp
+++ gcl27-2.7.0/lsp/gcl_defmacro.lsp
@@ -81,10 +81,10 @@
 	((stringp x) (gensym1s x))
 	((gensym1ig x))))
 			 
-(let* ((gsyms (mapl #'(lambda (x) (setf (car x) (gensym))) (make-list 50)))(syms gsyms))
+(let* ((gsyms (mapl #'(lambda (x) (setf (car x) (gensym))) (make-list 100)))(syms gsyms))
   (defun tsym (&optional r)
     (cond (r (setq syms gsyms) nil)
-	  ((or (pop syms) (error 'program-error :format-control "Out of symbols when binding lambda list" :format-arguments nil))))))
+	  ((or (pop syms) (gensym)))))); FIXME print? (error 'program-error :format-control "Out of symbols when binding lambda list" :format-arguments nil)
 
 (defun unbnd (k l &aux (lc (when (or (eq k '&optional) (eq k '&key)) (consp l)))
 	      (ln (if lc (pop l) l)) (ld (when lc (pop l))) (lp (when lc (car l)))
@@ -317,7 +317,7 @@
 
 (defmacro symbol-to-function (sym)
   (let* ((n (gensym))
-	 (gf (find-symbol "C-SYMBOL-GFDEF" (find-package :s))))
+	 (gf (find-symbol "C-SYMBOL-GFDEF" (find-package :cstruct))))
     `(when (symbolp ,sym)
        ,(if (fboundp gf) `(let ((,n (address (,gf ,sym))))
 			    (unless (= +objnull+ ,n) (nani ,n)))
--- gcl27-2.7.0.orig/lsp/gcl_deftype.lsp
+++ gcl27-2.7.0/lsp/gcl_deftype.lsp
@@ -265,6 +265,13 @@
 
 
 (defun ctp-num-bnd (x tp inc &aux (a (atom x))(nx (if a x (car x))))
+  (flet ((f (b)
+	   (when (fboundp 'fpe::break-on-floating-point-exceptions);FIXME
+	     (fpe::break-on-floating-point-exceptions :suspend t))
+	   (let ((z (float nx b)))
+	     (when (fboundp 'fpe::break-on-floating-point-exceptions)
+	       (fpe::break-on-floating-point-exceptions :suspend nil))
+	     (if (eql z nx) x (if a z (list z))))))
   (case tp
     (integer
      (let ((nx (if (unless a (integerp (rational nx))) (+ nx inc) nx)))
@@ -273,9 +280,8 @@
      (let ((z (rational nx)))
        (if (eql z nx) (if (integerp x) (list x) x)
 	   (if a z (list z)))))
-    ((short-float long-float)
-     (let ((z (float nx (if (eq tp 'short-float) 0.0s0 0.0))))
-       (if (eql z nx) x (if a z (list z)))))))
+    (short-float (f 0.0s0))
+    (long-float (f 0.0)))))
 
 (defun ctp-bnd (x tp inc)
   (if (eq x '*) x (ctp-num-bnd x tp inc)))
--- gcl27-2.7.0.orig/lsp/gcl_iolib.lsp
+++ gcl27-2.7.0/lsp/gcl_iolib.lsp
@@ -104,20 +104,18 @@
     (setf (fill-pointer (c-stream-object0 *sosm*)) 0)
     *sosm*))
 
-(defmacro with-output-to-string ((var &optional string &key element-type) . body)
+(defmacro with-output-to-string ((var &optional string &key (element-type ''character)) . body)
   (declare (optimize (safety 2)))
-  (let ((e (sgen "WITH-OUTPUT-TO-STRING")))
-    (multiple-value-bind (doc decls ctps body) (parse-body-header body)
-      (declare (ignorable doc))
-      `(let* ((,e ,element-type)
-	      (,var ,(if string
-			 `(make-string-output-stream-from-string ,string)
-			 `(or (get-sosm) (make-string-output-stream :element-type ,e))))
-	      (*sosm* (unless (eq ,var *sosm*) *sosm*)))
-	 ,@decls
-	 ,@ctps
-	 ,@body
-	 ,@(unless string `((get-output-stream-string ,var)))))))
+  (multiple-value-bind (doc decls ctps body) (parse-body-header body)
+    (declare (ignorable doc))
+    `(let* ((,var ,(if string
+		       `(progn ,element-type (make-string-output-stream-from-string ,string))
+		       `(or (get-sosm) (make-string-output-stream :element-type ,element-type))))
+	    (*sosm* (unless (eq ,var *sosm*) *sosm*)))
+       ,@decls
+       ,@ctps
+       ,@body
+       ,@(unless string `((get-output-stream-string ,var))))))
 
 
 (defun read-from-string (string &optional (eof-error-p t) eof-value
--- gcl27-2.7.0.orig/lsp/gcl_mnum.lsp
+++ gcl27-2.7.0/lsp/gcl_mnum.lsp
@@ -114,7 +114,37 @@
 				 ((floatp x) (complex x (float 0.0 x)))
 				 ((complex (float x 0.0) 0.0)))))
 		    ,body))
-	     body)))))
+	       body)))))
+
+  (defmacro defmlog (x &optional n)
+   (let* ((b (mdlsym x))
+	  (f (mdlsym (string-concatenate x "f")))
+	  (c (mdlsym (string-concatenate "c" x)))
+	  (cf (mdlsym (string-concatenate "c" x "f")))
+	  (ts (intern (string-upcase x)))
+	  (tp (get ts 'compiler::type-propagator)))
+     `(progn
+	(mdlsym ,x)
+	(mdlsym (string-concatenate ,x "f"))
+	(mdlsym (string-concatenate "c" ,x))
+	(mdlsym (string-concatenate "c" ,x "f"))
+	(setf (get ',b 'compiler::type-propagator)  ',tp)
+	(setf (get ',f 'compiler::type-propagator)  ',tp)
+	(setf (get ',c 'compiler::type-propagator)  ',tp)
+	(setf (get ',cf 'compiler::type-propagator) ',tp)
+	(defun ,(or n (intern (string-upcase x))) (x)
+	  ,@(unless (and n (not (string= (string-upcase n) (string-upcase x))))
+	      `((declare (optimize (safety 2)))
+		(check-type x number)))
+	  (etypecase x
+	    (fixnum (,b (float x 0.0)))
+	    (integer (ilog x))
+	    (rational (- (ilog (numerator x)) (ilog (denominator x))))
+	    (short-float (,f x))
+	    (long-float (,b x))
+	    (fcomplex (,cf x))
+	    (dcomplex (,c x))
+	    (complex (,c (complex (float (realpart x) 0.0) (float (imagpart x) 0.0)))))))))
 
  (defmacro defmabs (x &optional n)
    (let* ((i 'babs);(mdlsym (string-concatenate "l" x)))
@@ -218,7 +248,20 @@
 	 (rawatan2 x z))
 	((rawatan x))))
 
-(defmfun "log" rawlog (>= x 0))
+(defun ilog (n &aux (l (integer-length n)))
+  (+ (plog (float (/ n (ash 1 l)))) (* (plog 2.0) l)))
+(declaim (inline ilog))
+
+(defmlog "log" plog)
+(declaim (inline plog))
+
+(defun rawlog (x)
+  (cond
+    ((complexp x) (let* ((z (max (abs (realpart x)) (abs (imagpart x)))))
+		    (+ (plog z) (plog (complex (/ (realpart x) z) (/ (imagpart x) z))))))
+    ((minusp x) (+ (plog (- x)) (plog (complex -1 (if (floatp x) (float 0.0 x) 0.0)))))
+    ((plog x))))
+
 (defun log (x &optional b)
   (declare (optimize (safety 2)) (inline rawlog))
   (check-type x number)
--- gcl27-2.7.0.orig/lsp/gcl_numlib.lsp
+++ gcl27-2.7.0/lsp/gcl_numlib.lsp
@@ -25,6 +25,16 @@
 
 (in-package :system)
 
+(defun powm (a b c)
+  (declare (optimize (safety 1)))
+  (check-type a integer)
+  (check-type b (integer 0))
+  (check-type c (integer 0))
+  (if (typep b 'fixnum)
+      (gmp:mpz_powm_ui a b c)
+      (gmp:mpz_powm a b c)))
+(declaim (inline powm))
+
 (defconstant imag-one #C(0.0d0 1.0d0))
 
 (defun isqrt (i)
@@ -99,7 +109,16 @@
 (defun signum (x) 
   (declare (optimize (safety 1)))
   (check-type x number)
-  (if (zerop x) x (/ x (abs x))))
+  (if (zerop x) x
+      (typecase x
+	(rational (if (minusp x) -1 1))
+	(short-float (if (minusp x) -1.0s0 1.0s0))
+	(long-float (if (minusp x) -1.0 1.0))
+	(fcomplex (/ x (abs x)))
+	(dcomplex (/ x (abs x)))
+	(complex (let* ((y (max (abs (realpart x)) (abs (imagpart x))))
+			(z (complex (/ (realpart x) y) (/ (imagpart x) y))))
+		   (/ z (abs z)))))))
 
 (defun cis (x) 
   (declare (optimize (safety 1)))
@@ -216,7 +235,7 @@
   2)
 
 (defun atomic-tp-propagator (f &rest r);  tp &aux (atp (atomic-tp tp)))
-  (declare (dynamic-extenr t))
+  (declare (dynamic-extent r))
   (unless (member-if-not 'atomic-tp r)
     (let ((l (multiple-value-list (apply f (mapcar (lambda (x) (car (atomic-tp x))) r)))))
       (if (cdr l)
--- gcl27-2.7.0.orig/lsp/gcl_parse_namestring.lsp
+++ gcl27-2.7.0/lsp/gcl_parse_namestring.lsp
@@ -28,7 +28,7 @@
 
 (defun dir-parse (x sep sepfirst &optional (b 0))
   (when (stringp x)
-    (let ((i (search sep x :start2 b)));string-match spoils outer match results
+    (let ((i (position sep x :start b)));string-match spoils outer match results
       (when i
 	(let* ((y (dir-parse x sep sepfirst (1+ i)))
 	       (z (element x b i :directory))
@@ -55,7 +55,7 @@
 	    (error 'error :format-control "Host part of ~s does not match ~s" :format-arguments (list x host))))
       (let ((host (or host mhost (pathname-host def))))
 	(when (logical-pathname-host-p host)
-	  (let* ((dir (dir-parse (match-component x 2 :none) ";" :relative))
+	  (let* ((dir (dir-parse (match-component x 2 :none) #\; :relative))
 		 (edir (expand-home-dir dir)))
 	  (make-pathname :host host
 			 :device :unspecific
@@ -69,12 +69,12 @@
 
 (defun expand-home-dir (dir)
   (if (and (eq (car dir) :relative) (stringp (cadr dir)) (eql #\~ (aref (cadr dir) 0)))
-      (append (dir-parse (home-namestring (cadr dir)) "/" :absolute) (cddr dir))
+      (append (dir-parse (home-namestring (cadr dir)) #\/ :absolute) (cddr dir))
     dir))
 
 (defun pathname-parse (x b e)
   (when (and (eql b (string-match +generic-physical-pathname-regexp+ x b e)) (eql (match-end 0) e))
-    (let* ((dir (dir-parse (match-component x 1 :none) "/" :absolute))
+    (let* ((dir (dir-parse (match-component x 1 :none) #\/ :absolute))
 	   (edir (expand-home-dir dir)))
       (make-pathname :directory edir
 		     :name (match-component x 3 :name)
--- gcl27-2.7.0.orig/lsp/gcl_s.lsp
+++ gcl27-2.7.0/lsp/gcl_s.lsp
@@ -1,5 +1,5 @@
 ;; Copyright (C) 2024 Camm Maguire
-(in-package :s)
+(in-package :cstruct)
 
 (export '(lisp-type defdlfun +ks+ +fl+ strcat adjustable-vector adjustable-array matrix))
 (si::import-internal 'si::(\| & ^ ~ c+ c* << >> object double end-shft
--- gcl27-2.7.0.orig/lsp/gcl_seqlib.lsp
+++ gcl27-2.7.0/lsp/gcl_seqlib.lsp
@@ -307,8 +307,17 @@
 	(unless (or (< i2 start2) (>= i2 end2) (when l (endp s2)))
 	    (if from-end start1 (let ((ln1 (length s1))) (if end1 (min end1 ln1) ln1)))))))
 
+(defun nonregexp-string-p (str s e)
+  (when (and (stringp str) (zerop s) (if e (eql e (length str)) t));FIXME frame
+    (map nil (lambda (x) (case (char-code x) (#.(mapcar 'char-code (coerce "\\^$.|?*+()[]{}" 'list)) (return-from nonregexp-string-p nil)))) str)
+    t))
+(declaim (inline nonregexp-string-p))
 
 (defseq search (nil (s1 s2));consider (position-if-not 'eql-is-eq s1 :start start1 :end end1)
+  (unless (or test test-not key from-end)
+    (when (and (stringp s2) (nonregexp-string-p s1 start1 end1))
+      (let ((x (string-match s1 s2 start2 end2)))
+	(return-from search (unless (minusp x) x)))))
   (let ((n (max 0 (- (or end1 (length s1)) start1))))
     (do ((p (when l (if from-end (nthcdr (max 0 (1- n)) r) s)) (cdr p))
 	 (i (if from-end (- end2 n) start2) (if (>= i end2) (return nil) (+ i (if from-end -1 1)))));keep i seqbnd
@@ -381,8 +390,7 @@
    (string (sort sequence predicate :key key))
    (bit-vector (sort sequence predicate :key key))
    (otherwise 
-    (coerce (list-merge-sort (coerce sequence 'list) predicate key)
-	    (seqtype sequence)))))
+    (replace sequence (list-merge-sort (coerce sequence 'list) predicate key)))))
 
 (eval-when (compile eval)
   (defmacro f+ (x y) `(the fixnum (+ (the fixnum ,x) (the fixnum ,y))))
--- gcl27-2.7.0.orig/lsp/gcl_sf.lsp
+++ gcl27-2.7.0/lsp/gcl_sf.lsp
@@ -1,5 +1,5 @@
 ;; Copyright (C) 2024 Camm Maguire
-(in-package :s)
+(in-package :cstruct)
 
 (defun strcat (&rest r) (declare (dynamic-extent r)) (nstring-downcase (apply 'string-concatenate r)))
 
--- gcl27-2.7.0.orig/lsp/gcl_top.lsp
+++ gcl27-2.7.0/lsp/gcl_top.lsp
@@ -152,7 +152,7 @@
 		    (format t "~%~a>"
 			    (if (eq *package* (user-package)) ""
 			      (package-name *package*))))
-		  (reset-stack-limits)
+		  (reset-stack-limits t)
 		  ;; have to exit and re-enter to multiply stacks
 		  (cond (*multiply-stacks* (Return-from top-level1)))
 		  (setq - (locally (declare (notinline read))
--- gcl27-2.7.0.orig/lsp/gcl_type.lsp
+++ gcl27-2.7.0/lsp/gcl_type.lsp
@@ -555,7 +555,7 @@
 	((eq x '*) x)
 	((when (listp x)
 	   (case (car x)
-		 ((returns-exactly values) (cons (car x) (mapcar 'cmp-norm-tp (cdr x)))))))
+		 ((returns-exactly values) (cons (car x) (mapcar 'cmp-norm-tp (cdr x)))))));FIXME
 	((comp-tp1 x))))
 
 (defun tp-type1 (x)
--- gcl27-2.7.0.orig/mod/gcl_loop.lsp
+++ gcl27-2.7.0/mod/gcl_loop.lsp
@@ -1278,9 +1278,7 @@ collected result will be returned as the
   (cond ((or (null name) (null dtype) (eq dtype t)) nil)
 	((symbolp name)
 	 (unless (or (eq dtype t) (member (the symbol name) *loop-nodeclare*))
-	   (let ((dtype #-cmu dtype
-			#+cmu
-			(let ((init (loop-typed-init dtype)))
+	   (let ((dtype (let ((init (loop-typed-init dtype)))
 			  (if (typep init dtype)
 			      dtype
 			      `(or (member ,init) ,dtype)))))
@@ -1711,7 +1709,7 @@ collected result will be returned as the
   (multiple-value-bind (list constantp list-value) (loop-constant-fold-if-possible val)
     (let ((listvar var))
       (cond ((and var (symbolp var)) (loop-make-iteration-variable var list data-type))
-	    (t (loop-make-variable (setq listvar (loop-gentemp)) list 'list)
+	    (t (loop-make-variable (setq listvar (loop-gentemp)) list 't)
 	       (loop-make-iteration-variable var nil data-type)))
       (multiple-value-bind (list-step step-function) (loop-list-step listvar)
 	(declare #+(and (not LOOP-Prefer-POP) (not CLOE)) (ignore step-function))
--- gcl27-2.7.0.orig/o/cmpaux.c
+++ gcl27-2.7.0/o/cmpaux.c
@@ -616,7 +616,9 @@ gcl_init_or_load1(void (*fn)(void),const
     faslfile=open_stream(make_simple_string(file),smm_input,Cnil,sKerror);
     SEEK_TO_END_OFILE(faslfile->sm.sm_fp);
     set_min_cfd_self=1;
+    bds_bind(sLAload_pathnameA,make_simple_string(file));
     call_init(0,memory,faslfile);
+    bds_unwind1;
     set_min_cfd_self=0;
     close_stream(faslfile);
 
--- gcl27-2.7.0.orig/o/main.c
+++ gcl27-2.7.0/o/main.c
@@ -371,10 +371,6 @@ minimize_image(void) {
   nrbpage=0;
   resize_hole(0,t_relocatable,0);
 
-#ifdef USE_GPROF
-  gprof_cleanup();
-#endif
-  
 #if defined(BSD) || defined(ATT)  
   mbrk(core_end=heap_end);
 #endif
@@ -987,7 +983,9 @@ DEFUN("CATCH-FATAL",object,fScatch_fatal
   return Cnil;
 }
 
-DEFUN("RESET-STACK-LIMITS",object,fSreset_stack_limits,SI,0,0,NONE,OO,OO,OO,OO,(void),"") {
+DEFUN("RESET-STACK-LIMITS",object,fSreset_stack_limits,SI,0,1,NONE,OO,OO,OO,OO,(object cs_org_reset,...),"") {
+
+  if (!INIT_NARGS(0)) cs_org_reset=Cnil;
 
   if(catch_fatal <0) catch_fatal=1;
 #ifdef SGC	
@@ -1009,15 +1007,23 @@ DEFUN("RESET-STACK-LIMITS",object,fSrese
     ihs_limit = ihs_org + stack_multiple *  IHSSIZE;
   else
     error("can't reset ihs_limit");
-  cs_org=alloca(1);
+
+  if (cs_org_reset!=Cnil) {
+
+    cs_org=alloca(1);
+
 #ifdef __ia64__
- {
-   extern void * GC_save_regs_in_stack();
-   cs_org2=GC_save_regs_in_stack();
- }
+    {
+      extern void * GC_save_regs_in_stack();
+      cs_org2=GC_save_regs_in_stack();
+    }
 #endif
-  /* reset_cstack_limit(i); */
- RETURN1(Cnil);
+    /* reset_cstack_limit(i); */
+
+  }
+
+  RETURN1(Cnil);
+
 }
 
 #define COPYSTACK(org,p,typ,lim,top,geta,size) \
--- gcl27-2.7.0.orig/o/num_sfun.c
+++ gcl27-2.7.0/o/num_sfun.c
@@ -766,87 +766,6 @@ FFN(siLmodf)(void)
 
 }
 
-#define CTMP(a_) (type_of(a_)==t_fixnum ? stoi(fix(a_)) : MP(a_))
-
-object 
-powm_bbb(object a,object i,object m) {
-  object ans=new_bignum();
-  if (type_of(i)==t_fixnum)
-    mpz_powm_ui(MP(ans),CTMP(a),fix(i),CTMP(m));
-  else
-    mpz_powm(MP(ans),CTMP(a),MP(i),CTMP(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_bfb(object a,fixnum i,object m) {
-  object ans=new_bignum();
-  mpz_powm_ui(MP(ans),CTMP(a),i,CTMP(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_fbb(fixnum a,object i,object m) {
-  object ans=new_bignum();
-  if (type_of(i)==t_fixnum)
-    mpz_powm_ui(MP(ans),stoi(a),fix(i),CTMP(m));
-  else
-    mpz_powm(MP(ans),stoi(a),MP(i),CTMP(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_ffb(fixnum a,fixnum i,object m) {
-  object ans=new_bignum();
-  mpz_powm_ui(MP(ans),stoi(a),i,CTMP(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_bbf(object a,object i,fixnum m) {
-  object ans=new_bignum();
-  if (type_of(i)==t_fixnum)
-    mpz_powm_ui(MP(ans),CTMP(a),fix(i),stoi(m));
-  else
-    mpz_powm(MP(ans),CTMP(a),MP(i),stoi(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_bff(object a,fixnum i,fixnum m) {
-  object ans=new_bignum();
-  mpz_powm_ui(MP(ans),CTMP(a),i,stoi(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_fbf(fixnum a,object i,fixnum m) {
-  object ans=new_bignum();
-  if (type_of(i)==t_fixnum)
-    mpz_powm_ui(MP(ans),stoi(a),fix(i),stoi(m));
-  else
-    mpz_powm(MP(ans),stoi(a),MP(i),stoi(m));
-  return(maybe_replace_big(ans));
-}
-
-object 
-powm_fff(fixnum a,fixnum i,fixnum m) {
-  object ans=new_bignum();
-  mpz_powm_ui(MP(ans),stoi(a),i,stoi(m));
-  return(maybe_replace_big(ans));
-}
-
-
-DEFUN("POWM",object,fSpowm,SI,3,3,NONE,OO,OO,OO,OO,(object a,object i,object m),"") {
-
-  check_type_integer(&a);
-  check_type_integer(&i);
-  check_type_integer(&m);
-  RETURN1(powm_bbb(a,i,m));
-
-}
-
-
 DEFUN("ISNAN",object,fSisnan,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") {
 
   switch (type_of(x)) {
--- gcl27-2.7.0.orig/o/package.d
+++ gcl27-2.7.0/o/package.d
@@ -1253,7 +1253,6 @@ gcl_init_package()
 #endif
 #endif
 
-	make_package(make_simple_string("C"),Cnil,Cnil,0,0);
 	gmp_package=make_package(make_simple_string("GMP"),Cnil,Cnil,0,0);
 
 	/*  There is no need to enter a package as a mark origin.  */
--- gcl27-2.7.0.orig/o/regexpr.c
+++ gcl27-2.7.0/o/regexpr.c
@@ -37,6 +37,7 @@ gcl_regerror(char *s)
 		not_a_string(x)
 
 
+DEFVAR("*COMPILED-REGEXP-CACHE*",sSAcompiled_regexp_cacheA,SI,MMcons(MMcons(sLnil,sLnil),sLnil),"");
 DEFVAR("*MATCH-DATA*",sSAmatch_dataA,SI,sLnil,"");
 DEFVAR("*CASE-FOLD-SEARCH*",sSAcase_fold_searchA,SI,sLnil,
        "Non nil means that a string-match should ignore case");
@@ -112,8 +113,6 @@ be over written.   \
   fixnum nargs=INIT_NARGS(2);
   int i,ans;
   int len,start,end;
-  static char buf[400],case_fold;
-  static regexp *saved_compiled_regexp;
   va_list ap;
   object v=sSAmatch_dataA->s.s_dbind,l=Cnil,f=OBJNULL;
   char **pp,*str,save_c=0;
@@ -136,62 +135,69 @@ be over written.   \
      FEerror("Bad start or end",0);
 
   len=VLEN(pattern);
-   if (len==0) {
-     /* trivial case of empty pattern */
-     for (i=0;i<NSUBEXP;i++) 
-       ((fixnum *)v->a.a_self)[i]=i ? -1 : 0;
-     memcpy(((fixnum *)v->a.a_self)+NSUBEXP,((fixnum *)v->a.a_self),NSUBEXP*sizeof(*((fixnum *)v->a.a_self)));
-     RETURN1(0);
-   }
+  if (len==0) {
+    /* trivial case of empty pattern */
+    for (i=0;i<NSUBEXP;i++)
+      ((fixnum *)v->a.a_self)[i]=i ? -1 : 0;
+    memcpy(((fixnum *)v->a.a_self)+NSUBEXP,((fixnum *)v->a.a_self),NSUBEXP*sizeof(*((fixnum *)v->a.a_self)));
+    RETURN1(0);
+  }
 
-   {
+  {
 
-     regexp *compiled_regexp=saved_compiled_regexp;
+    regexp *compiled_regexp;
 
-     BEGIN_NO_INTERRUPT;
+    BEGIN_NO_INTERRUPT;
 
-     case_fold_search = sSAcase_fold_searchA->s.s_dbind != sLnil ? 1 : 0;
-     
-     if (type_of(pattern)==t_vector)
-       
-       compiled_regexp=(void *)pattern->ust.ust_self;
+    if (type_of(pattern)==t_vector)
 
-     else if (case_fold != case_fold_search || len != strlen(buf) || memcmp(pattern->ust.ust_self,buf,len)) 
+      compiled_regexp=(void *)pattern->ust.ust_self;
 
-       compiled_regexp=saved_compiled_regexp=(regexp *)FFN(fScompile_regexp)(pattern)->v.v_self;
+    else {
 
+      object cache=sSAcompiled_regexp_cacheA->s.s_dbind;
 
-     str=string->st.st_self;
-     if (NULL_OR_ON_C_STACK(str+end) || str+end==(void *)compiled_regexp) {
+      if (cache->c.c_car->c.c_car!=pattern || cache->c.c_car->c.c_cdr!=sSAcase_fold_searchA->s.s_dbind) {
+	cache->c.c_car->c.c_car=pattern;
+	cache->c.c_car->c.c_cdr=sSAcase_fold_searchA->s.s_dbind;
+	cache->c.c_cdr=FFN(fScompile_regexp)(pattern);
+      }
 
-       if (!(str=alloca(VLEN(string)+1)))
-	 FEerror("Cannot allocate memory on C stack",0);
-       memcpy(str,string->st.st_self,VLEN(string));
+      compiled_regexp=(regexp *)cache->c.c_cdr->v.v_self;
 
-     } else
-       save_c=str[end];
-     str[end]=0;
+    }
 
-     ans = regexec(compiled_regexp,str+start,str,end-start);
+    str=string->st.st_self;
+    if (NULL_OR_ON_C_STACK(str+end) || str+end==(void *)compiled_regexp) {
 
-     str[end] = save_c;
+      if (!(str=alloca(VLEN(string)+1)))
+	FEerror("Cannot allocate memory on C stack",0);
+      memcpy(str,string->st.st_self,VLEN(string));
 
-     if (!ans ) {
-       END_NO_INTERRUPT;
-       RETURN1((object)-1);
-     }
+    } else
+      save_c=str[end];
+    str[end]=0;
 
-     pp=compiled_regexp->startp;
-     for (i=0;i<NSUBEXP;i++,pp++)
-       ((fixnum *)v->a.a_self)[i]=*pp ? *pp-str : -1;
-     pp=compiled_regexp->endp;
-     for (;i<2*NSUBEXP;i++,pp++)
-       ((fixnum *)v->a.a_self)[i]=*pp ? *pp-str : -1;
+    ans = regexec(compiled_regexp,str+start,str,end-start);
 
-     END_NO_INTERRUPT;
-     RETURN1((object)((fixnum *)v->a.a_self)[0]);
+    str[end] = save_c;
 
-   }
+    if (!ans ) {
+      END_NO_INTERRUPT;
+      RETURN1((object)-1);
+    }
+
+    pp=compiled_regexp->startp;
+    for (i=0;i<NSUBEXP;i++,pp++)
+      ((fixnum *)v->a.a_self)[i]=*pp ? *pp-str : -1;
+    pp=compiled_regexp->endp;
+    for (;i<2*NSUBEXP;i++,pp++)
+      ((fixnum *)v->a.a_self)[i]=*pp ? *pp-str : -1;
+
+    END_NO_INTERRUPT;
+    RETURN1((object)((fixnum *)v->a.a_self)[0]);
+
+  }
 
 }
 object
--- gcl27-2.7.0.orig/pcl/gcl_pcl_pkg.lisp
+++ gcl27-2.7.0/pcl/gcl_pcl_pkg.lisp
@@ -40,7 +40,7 @@
     (make-package ':iterate :use '(:lisp :walker)))
 
 (if (find-package ':pcl)
-    (use-package '(:walker :iterate :lisp :s) ':pcl)
+    (use-package '(:walker :iterate :lisp :cstruct) ':pcl)
     (make-package ':pcl :use '(:walker :iterate :lisp)))
 
 (import 'si::(clines defentry defcfun object void int double non-negative-fixnum macro memq seqind structurep structure-def structure-ref std-instance funcallable-std-instance) :pcl)
--- gcl27-2.7.0.orig/pcl/sys-package.lisp
+++ gcl27-2.7.0/pcl/sys-package.lisp
@@ -20,7 +20,7 @@
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "PCL")
  (COMMON-LISP::MAKE-PACKAGE
-  "PCL" :USE '("S" "WALKER" "ITERATE" "COMMON-LISP")))
+  "PCL" :USE '("CSTRUCT" "WALKER" "ITERATE" "COMMON-LISP")))
 
 ;;; Definitions for package WALKER of type EXPORT
 (COMMON-LISP::IMPORT
@@ -2209,24 +2209,26 @@
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
    PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION CLASS)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS)| PCL::FIRST-P
-   PCL::DFUN-INFO-ACCESSOR-TYPE S::C-FLOAT-DOUBLE->
+   PCL::DFUN-INFO-ACCESSOR-TYPE CSTRUCT::C-FLOAT-DOUBLE->
    PCL::SHORT-COMBINATION-OPERATOR COMMON-LISP::NSUBLIS
    PCL::GFS-OF-TYPE PCL::COPY-ACCESSOR-DFUN-INFO PCL::*MF1P*
-   COMMON-LISP::YES-OR-NO-P S::C-SET-HASHTABLE-SELF
+   COMMON-LISP::YES-OR-NO-P CSTRUCT::C-SET-HASHTABLE-SELF
    PCL::METHOD-CLASS-NAME COMMON-LISP::INTERACTIVE-STREAM-P PCL::CAM
    PCL::DEFSTRUCT-P PCL::ONE-INDEX-P PCL::ONE-ORDER-P
    PCL::INTERN-FUNCTION-NAME PCL::SLOTD PCL::INSTANCE-BOUNDP
-   PCL::INSTANCE-WRITER S::C-FLOAT-FCOMPLEX-== S::C-FLOAT-DCOMPLEX-==
-   PCL::KNOWN-TYPE PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PV-CELL)|
-   PCL::NON-SETF-CASE PCL::BOTTOM PCL::SORT-CALLS PCL::MAKE-METHOD-SPEC
-   PCL::GCL_PCL_BOOT COMMON-LISP::SIMPLE-CONDITION-FORMAT-CONTROL
+   PCL::INSTANCE-WRITER CSTRUCT::C-FLOAT-FCOMPLEX-==
+   CSTRUCT::C-FLOAT-DCOMPLEX-== PCL::KNOWN-TYPE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PV-CELL)| PCL::NON-SETF-CASE
+   PCL::BOTTOM PCL::SORT-CALLS PCL::MAKE-METHOD-SPEC PCL::GCL_PCL_BOOT
+   COMMON-LISP::SIMPLE-CONDITION-FORMAT-CONTROL
    PCL::|(SETF GF-DFUN-STATE)| PCL::FAST-INSTANCE-BOUNDP- PCL::SPEC
    PCL::R/W PCL::CONVERT-TABLE COMMON-LISP::CLOSE PCL::COLLECTING-ONCE
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
    PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::CONSTANTS PCL::TWO-CLASS
    PCL::TWO-CLASS- PCL::CLASS-SLOTDS PCL::.FAST-CALL-METHOD.
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LENGTH)| S::C-FLOAT-FLOAT-==
-   PCL::STD-CLASS PCL::GET-CACHE-VECTOR S::C-SET-FUNCTION-ARGD
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LENGTH)|
+   CSTRUCT::C-FLOAT-FLOAT-== PCL::STD-CLASS PCL::GET-CACHE-VECTOR
+   CSTRUCT::C-SET-FUNCTION-ARGD
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NEXT-METHOD-CALL)| PCL::VAL
    PCL::CPD-CLASS PCL::READER-METHOD
    PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
@@ -2266,7 +2268,7 @@
    PCL::MAKE-DUMMY-VAR PCL::UPDATE-GFS-OF-CLASS
    COMMON-LISP::RANDOM-STATE-P PCL::FINALIZEP PCL::|__si::MAKE-CACHING|
    PCL::SUPERCLASSES-COMPATIBLE-P PCL::SPECLS PCL::ARGLISTP
-   PCL::GCL_PCL_METHODS PCL::R+SNL PCL::GF-CALL-FORM S::*LONG
+   PCL::GCL_PCL_METHODS PCL::R+SNL PCL::GF-CALL-FORM CSTRUCT::*LONG
    PCL::CONSTANT-VALUE- PCL::N-N-P PCL::GCL_PCL_DEFS PCL::INSTANCE-SET
    PCL::EXTERNAL-COUNT COMMON-LISP::DELETE-FILE
    COMMON-LISP::WITH-HASH-TABLE-ITERATOR PCL::DEFSTRUCT-CONSTRUCTOR
@@ -2277,23 +2279,23 @@
    COMMON-LISP::HASH-TABLE-REHASH-THRESHOLD PCL::NO PCL::FSC-INSTANCE-P
    COMMON-LISP::DEFINE-CONDITION PCL::|(BOUNDP METHOD)|
    PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES
-   COMMON-LISP::RANDOM-STATE S::C-SET-PACKAGE-USELIST
-   S::C-SET-PACKAGE-USEDBYLIST COMMON-LISP::UPPER-CASE-P
+   COMMON-LISP::RANDOM-STATE CSTRUCT::C-SET-PACKAGE-USELIST
+   CSTRUCT::C-SET-PACKAGE-USEDBYLIST COMMON-LISP::UPPER-CASE-P
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LIMIT-FN)|
    PCL::*PRECOMPILING-LAP* PCL::RAISE-METATYPE
-   S::C-SET-PATHNAME-NAMESTRING COMMON-LISP::GO
+   CSTRUCT::C-SET-PATHNAME-NAMESTRING COMMON-LISP::GO
    PCL::ALLOCATE-CACHE-VECTOR PCL::ONE-INDEX-DFUN-INFO
    PCL::USE-CACHING-DFUN-P COMMON-LISP::DO COMMON-LISP::GRAPHIC-CHAR-P
    PCL::GCL_PCL_DFUN PCL::|(WRITER INITARGS)| PCL::PREDICATE-NAME-P
    PCL::ADD-NAMED-METHOD PCL::COPY-STD-INSTANCE
    PCL::BUILT-IN-WRAPPER-OF PCL::METHOD-FUNCTION-RETURNING-T
-   COMMON-LISP::PATHNAME-TYPE S::C/ PCL::ONE-INDEX-CACHE
+   COMMON-LISP::PATHNAME-TYPE CSTRUCT::C/ PCL::ONE-INDEX-CACHE
    COMMON-LISP::*PRINT-PPRINT-DISPATCH* PCL::MAKE-KEYWORD PCL::INITFORM
    PCL::RFORMS PCL::MAP-ALL-ORDERS COMMON-LISP::STANDARD-CHAR
-   S::C-SET-HASHTABLE-CACHE COMMON-LISP::PROCLAIM
+   CSTRUCT::C-SET-HASHTABLE-CACHE COMMON-LISP::PROCLAIM
    PCL::REMOVE-BOUNDP-METHOD COMMON-LISP::BLOCK PCL::NEW-VALUE-FORM
    PCL::BUILT-IN-CLASS-SIMPLE-TYPEP-FN PCL::|PV-TABLE SLOT3|
-   S::C-SET-PATHNAME-TYPE PCL::CLASS-SYMBOL PCL::|CHECKING SLOT1|
+   CSTRUCT::C-SET-PATHNAME-TYPE PCL::CLASS-SYMBOL PCL::|CHECKING SLOT1|
    COMMON-LISP::LOWER-CASE-P COMMON-LISP::// PCL::CASE-SYM PCL::BODY
    PCL::TWO-CLASS-DFUN-INFO COMMON-LISP::READ-SEQUENCE PCL::KCL-PATCHES
    PCL::EARLY-METHOD PCL::CACHED-COMBINED-INITARGS-FORM-LIST
@@ -2308,18 +2310,19 @@
    PCL::|PCL::TRACED-METHOD class predicate| PCL::GCL_PCL_FNGEN
    COMMON-LISP::MULTIPLE-VALUE-BIND COMMON-LISP::*TRACE-OUTPUT*
    PCL::WRAPPERS-REV PCL::EARLY-CLASS-PRECEDENCE-LIST-SYMBOL
-   PCL::COPY-FAST-INSTANCE-BOUNDP S::C-SET-HASHTABLE-STATIC
+   PCL::COPY-FAST-INSTANCE-BOUNDP CSTRUCT::C-SET-HASHTABLE-STATIC
    PCL::USE-PACKAGE-PCL PCL::CACHED-NAME PCL::.UMETHODS.
    PCL::COMPUTE-CONSTANTS PCL::LINE-PRIMARY PCL::CALL-NO-NEXT-METHOD
    PCL::DISPATCH-DFUN-COST COMMON-LISP::USE-PACKAGE PCL::SMETHODS
-   PCL::SLOT-WRITER-SYMBOL PCL::FOR-ACCESSOR-P S::C-SET-PATHNAME-NAME
-   S::C-SYMBOL-HPACK PCL::|(WRITER DEFSTRUCT-CONSTRUCTOR)|
-   PCL::|PV-TABLE SLOT1| PCL::GFS-TO-DO PCL::TRANSFORM PCL::TRANSFORMS
-   PCL::NAME-DECL S::C-PATHNAME-HOST
-   PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST COMMON-LISP::PATHNAME-DEVICE
-   PCL::GENERATOR-LAMBDA PCL::STANDARD-WRITER-METHOD-P
-   PCL::PORT-DIRECTORY PCL::FREE-OLD-CACHE-P COMMON-LISP::SUBSEQ
-   PCL::METATYPE S::C-ARRAY-HASFILLP S::C-SYMBOL-HASH
+   PCL::SLOT-WRITER-SYMBOL PCL::FOR-ACCESSOR-P
+   CSTRUCT::C-SET-PATHNAME-NAME CSTRUCT::C-SYMBOL-HPACK
+   PCL::|(WRITER DEFSTRUCT-CONSTRUCTOR)| PCL::|PV-TABLE SLOT1|
+   PCL::GFS-TO-DO PCL::TRANSFORM PCL::TRANSFORMS PCL::NAME-DECL
+   CSTRUCT::C-PATHNAME-HOST PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST
+   COMMON-LISP::PATHNAME-DEVICE PCL::GENERATOR-LAMBDA
+   PCL::STANDARD-WRITER-METHOD-P PCL::PORT-DIRECTORY
+   PCL::FREE-OLD-CACHE-P COMMON-LISP::SUBSEQ PCL::METATYPE
+   CSTRUCT::C-ARRAY-HASFILLP CSTRUCT::C-SYMBOL-HASH
    PCL::CHECK-LAMBDA-LIST
    PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLASSES
    PCL::CLAUSE PCL::*NAME->CLASS->SLOTD-TABLE*
@@ -2331,9 +2334,9 @@
    PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::PLIST-P
    COMMON-LISP::SET-EXCLUSIVE-OR COMMON-LISP::GENSYM
    PCL::|(WRITER ARG-INFO)| COMMON-LISP::REALPART
-   S::C-SET-PATHNAME-DEVICE PCL::PLIST PCL::|(WRITER OPERATOR)|
+   CSTRUCT::C-SET-PATHNAME-DEVICE PCL::PLIST PCL::|(WRITER OPERATOR)|
    PCL::|PV-TABLE SLOT0| COMMON-LISP::CODE-CHAR PCL::POS PCL::MLIST
-   S::C-SET-OCOMPLEX-REAL PCL::SKIP-FAST-SLOT-ACCESS-P
+   CSTRUCT::C-SET-OCOMPLEX-REAL PCL::SKIP-FAST-SLOT-ACCESS-P
    SYSTEM::STD-INSTANCE COMMON-LISP::FLOAT-RADIX PCL::TYPE-SYM
    PCL::|DFUN-INFO SLOT0| PCL::ALLOC PCL::PRINT-CACHE
    PCL::CLASSES-LIST-P COMMON-LISP::READ-CHAR COMMON-LISP::PEEK-CHAR
@@ -2343,9 +2346,9 @@
    COMMON-LISP::SET-MACRO-CHARACTER COMMON-LISP::GET-MACRO-CHARACTER
    PCL::METHOD-COMBINATION-SIMPLE-TYPEP-FN PCL::MNAME
    PCL::MAKE-DLAP-LAMBDA-LIST PCL::PROBE-CACHE PCL::KNX PCL::SPECL1
-   PCL::UNSPECIALIZED-LAMBDA-LIST S::C-RANDOM-STATE S::C-SYMBOL-STYPE
-   PCL::EXPAND-EMF-CALL-METHOD PCL::OPTIONS PCL::FNAME
-   COMMON-LISP::INPUT-STREAM-P PCL::C-A-M-GF
+   PCL::UNSPECIALIZED-LAMBDA-LIST CSTRUCT::C-RANDOM-STATE
+   CSTRUCT::C-SYMBOL-STYPE PCL::EXPAND-EMF-CALL-METHOD PCL::OPTIONS
+   PCL::FNAME COMMON-LISP::INPUT-STREAM-P PCL::C-A-M-GF
    PCL::RAW-INSTANCE-ALLOCATOR PCL::DNAME PCL::LOAD-BINARY PCL::CNAME
    PCL::CLASS-SLOT-P PCL::DEFSTRUCT-ACCESSOR-SYMBOL PCL::READERS-INIT
    COMMON-LISP::*PRINT-PRETTY* PCL::|(SETF DOCUMENTATION)|
@@ -2353,25 +2356,25 @@
    PCL::FUNCALLABLE-INSTANCE-DATA PCL::EARLY-CLASS-SIZE PCL::FREE-CACHE
    PCL::FROM-CACHE PCL::CHECK-QUALIFIERS COMMON-LISP::*QUERY-IO*
    PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1 PCL::COPY-CACHE
-   PCL::DECLARATION-SPECIFIERS COMMON-LISP::*PRINT-ARRAY* S::*SHORT
-   PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR PCL::*SLOT-UNBOUND*
-   PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE PCL::FDEFINE-CAREFULLY
-   SYSTEM::DEFCFUN PCL::FILL-CACHE PCL::BIND-FAST-LEXICAL-METHOD-MACROS
-   COMMON-LISP::*LOAD-VERBOSE* PCL::CLOE-LOW COMMON-LISP::FIND-IF
-   PCL::MAKE-CACHE PCL::SHOW-EMF-CALL-TRACE
-   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+   PCL::DECLARATION-SPECIFIERS COMMON-LISP::*PRINT-ARRAY*
+   CSTRUCT::*SHORT PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
+   PCL::*SLOT-UNBOUND* PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE
+   PCL::FDEFINE-CAREFULLY SYSTEM::DEFCFUN PCL::FILL-CACHE
+   PCL::BIND-FAST-LEXICAL-METHOD-MACROS COMMON-LISP::*LOAD-VERBOSE*
+   PCL::CLOE-LOW COMMON-LISP::FIND-IF PCL::MAKE-CACHE
+   PCL::SHOW-EMF-CALL-TRACE PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
    PCL::STANDARD-BOUNDP-METHOD-P PCL::GENERATE-DISCRIMINATION-NET
-   PCL::FOR S::*FLOAT COMMON-LISP::POSITION COMMON-LISP::MAKE-SEQUENCE
-   PCL::FIXUP PCL::METHOD-FUNCTION-METHOD
+   PCL::FOR CSTRUCT::*FLOAT COMMON-LISP::POSITION
+   COMMON-LISP::MAKE-SEQUENCE PCL::FIXUP PCL::METHOD-FUNCTION-METHOD
    PCL::CACHED-DEFAULT-INITARGS-FUNCTION
    PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
    PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
    PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
    PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
-   PCL::GCL_PCL_ITERATE S::C-SYMBOL-NAME PCL::CANONICAL-SLOT
+   PCL::GCL_PCL_ITERATE CSTRUCT::C-SYMBOL-NAME PCL::CANONICAL-SLOT
    PCL::|(WRITER CLASS-EQ-SPECIALIZER)| PCL::DEFCONSTRUCTOR
-   PCL::%NO-PRIMARY-METHOD S::C-SET-PACKAGE-INTERNAL_FP
-   S::C-SET-PACKAGE-EXTERNAL_FP
+   PCL::%NO-PRIMARY-METHOD CSTRUCT::C-SET-PACKAGE-INTERNAL_FP
+   CSTRUCT::C-SET-PACKAGE-EXTERNAL_FP
    PCL::CACHED-COMBINED-INITIALIZE-FUNCTION PCL::FORCE-CACHE-FLUSHES
    PCL::INITIAL-
    PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
@@ -2383,7 +2386,7 @@
    COMMON-LISP::BOOLE-C2 PCL::RENEW-SYS-FILES
    COMMON-LISP::SET-DISPATCH-MACRO-CHARACTER
    COMMON-LISP::GET-DISPATCH-MACRO-CHARACTER SYSTEM::C-FCOMPLEX-==
-   SYSTEM::C-DCOMPLEX-== COMMON-LISP::COMPLEMENT S::C-SPICE-DUMMY
+   SYSTEM::C-DCOMPLEX-== COMMON-LISP::COMPLEMENT CSTRUCT::C-SPICE-DUMMY
    PCL::|SYSTEM:S-DATA SLOT9| PCL::MNAME-SYM PCL::COPY-ARG-INFO
    PCL::COMPUTE-SLOT-ACCESSOR-INFO PCL::*SPECIALS*
    COMMON-LISP::RESTART-CASE PCL::PV-BINDING1 COMMON-LISP::PAIRLIS
@@ -2401,18 +2404,18 @@
    PCL::PROGN-FORM PCL::CONSTS PCL::|(READER INITIALIZE-INFO)|
    COMMON-LISP::ARRAY-IN-BOUNDS-P PCL::INCLUDE PCL::ENV
    PCL::GET-MAKE-INSTANCE-FUNCTION PCL::CNV PCL::|SYSTEM:S-DATA SLOT7|
-   PCL::OPTIONAL S::C-SYMBOL-SFDEF S::C-SYMBOL-GFDEF S::C-SYMBOL-MFLAG
-   COMMON-LISP::DEPOSIT-FIELD PCL::FIX-EARLY-GENERIC-FUNCTIONS
-   PCL::*EQL-SPECIALIZER-TABLE*
+   PCL::OPTIONAL CSTRUCT::C-SYMBOL-SFDEF CSTRUCT::C-SYMBOL-GFDEF
+   CSTRUCT::C-SYMBOL-MFLAG COMMON-LISP::DEPOSIT-FIELD
+   PCL::FIX-EARLY-GENERIC-FUNCTIONS PCL::*EQL-SPECIALIZER-TABLE*
    COMMON-LISP::*READ-DEFAULT-FLOAT-FORMAT*
    PCL::EARLY-COLLECT-DEFAULT-INITARGS PCL::GET-WRAPPERS-FROM-CLASSES
    PCL::OMETHOD PCL::TMETHOD
    PCL::|(INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
    PCL::DISPATCH-DFUN-INFO PCL::FALSE-CLAUSES PCL::EARLY-CLASS-NAME-OF
-   S::C-SYMBOL-DBIND PCL::.PV-TABLE. PCL::TOP COMMON-LISP::RATIONAL
-   PCL::|(READER DEFSTRUCT-CONSTRUCTOR)| COMMON-LISP::NOTANY
-   S::C-SET-PACKAGE-LINK PCL::DLINE PCL::SN COMMON-LISP::POP
-   COMMON-LISP::PPRINT PCL::ON COMMON-LISP::CONDITION
+   CSTRUCT::C-SYMBOL-DBIND PCL::.PV-TABLE. PCL::TOP
+   COMMON-LISP::RATIONAL PCL::|(READER DEFSTRUCT-CONSTRUCTOR)|
+   COMMON-LISP::NOTANY CSTRUCT::C-SET-PACKAGE-LINK PCL::DLINE PCL::SN
+   COMMON-LISP::POP COMMON-LISP::PPRINT PCL::ON COMMON-LISP::CONDITION
    PCL::|SYSTEM:S-DATA SLOT6| PCL::OPTION COMMON-LISP::READTABLE
    COMMON-LISP::READTABLEP PCL::METHOD-COMBINATION-TYPE
    PCL::GCL_PCL_BRAID PCL::IN PCL::.NEXT-METHOD. PCL::FN SYSTEM::SEQIND
@@ -2421,15 +2424,16 @@
    COMMON-LISP::BIT-VECTOR-P COMMON-LISP::TYPE-ERROR-DATUM
    PCL::|(CALL REAL-ADD-METHOD)| PCL::|(CALL REAL-REMOVE-METHOD)|
    PCL::|(CALL REAL-GET-METHOD)| PCL::ONE-INDEX-DFUN-INFO-CACHE
-   PCL::|(READER OPERATOR)| PCL::GET-INSTANCE-WRAPPER-OR-NIL S::C-T-PD1
-   SYSTEM::>> S::C-SET-PACKAGE-INTERNAL S::C-SET-PACKAGE-EXTERNAL
-   PCL::DO-STANDARD-DEFSETF-1 PCL::*CLASS-PV-TABLE-TABLE*
-   PCL::ALLOW-OTHER-KEYS PCL::|SYSTEM:S-DATA SLOT5|
-   PCL::DEFINE-DEFAULT-METHOD PCL::BOOTSTRAP-GET-SLOT PCL::INFO
-   COMMON-LISP::*PRINT-MISER-WIDTH* PCL::WRAPPERS+VALUE
-   PCL::|(SETF CLASS-DIRECT-SLOTS)| PCL::|(SETF CLASS-SLOTS)|
-   PCL::COMPUTE-LINE-SIZE PCL::WITHOUT-INTERRUPTS PCL::SCLASS
-   PCL::MAKE-DISPATCH-DFUN WALKER::VARIABLE-DECLARATION PCL::FAST-SYM
+   PCL::|(READER OPERATOR)| PCL::GET-INSTANCE-WRAPPER-OR-NIL
+   CSTRUCT::C-T-PD1 SYSTEM::>> CSTRUCT::C-SET-PACKAGE-INTERNAL
+   CSTRUCT::C-SET-PACKAGE-EXTERNAL PCL::DO-STANDARD-DEFSETF-1
+   PCL::*CLASS-PV-TABLE-TABLE* PCL::ALLOW-OTHER-KEYS
+   PCL::|SYSTEM:S-DATA SLOT5| PCL::DEFINE-DEFAULT-METHOD
+   PCL::BOOTSTRAP-GET-SLOT PCL::INFO COMMON-LISP::*PRINT-MISER-WIDTH*
+   PCL::WRAPPERS+VALUE PCL::|(SETF CLASS-DIRECT-SLOTS)|
+   PCL::|(SETF CLASS-SLOTS)| PCL::COMPUTE-LINE-SIZE
+   PCL::WITHOUT-INTERRUPTS PCL::SCLASS PCL::MAKE-DISPATCH-DFUN
+   WALKER::VARIABLE-DECLARATION PCL::FAST-SYM
    PCL::GET-WRAPPER-CACHE-NUMBER PCL::IF* PCL::INITIALIZE-INFO-WRAPPER
    COMMON-LISP::DECLARE PCL::REAL-MF-P PCL::EXTRACT-DECLARATIONS
    COMMON-LISP::SPECIAL PCL::OCACHE PCL::NO-OF-INSTANCE-SLOTS
@@ -2500,7 +2504,7 @@
    PCL::COMPUTE-DEFAULT-INITARGS PCL::|(READER CLASS-EQ-SPECIALIZER)|
    PCL::NCLASSES COMMON-LISP::SOFTWARE-VERSION PCL::.LAP-REST-ARG.
    PCL::|SYSTEM:S-DATA SLOT2| PCL::DEFAULT-METHOD-ONLY PCL::EMIT
-   S::*USHORT PCL::CHECKING PCL::MAKE-ACCESSOR-DFUN-INFO
+   CSTRUCT::*USHORT PCL::CHECKING PCL::MAKE-ACCESSOR-DFUN-INFO
    PCL::EMIT-IN-CHECKING-CACHE-P PCL::DO-SATISFIES-DEFTYPE
    PCL::CHECK-APPLICABLE-KEYWORDS COMMON-LISP::LOAD
    PCL::|(READER DEFSTRUCT-ACCESSOR-SYMBOL)| PCL::CANONICAL-OPTIONS
@@ -2509,12 +2513,12 @@
    COMMON-LISP::COPY-PPRINT-DISPATCH PCL::|SYSTEM:S-DATA SLOT1|
    PCL::GF-INFO-C-A-M-EMF-STD-P COMMON-LISP::WITH-SIMPLE-RESTART
    PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST PCL::|(READER WRAPPER)|
-   PCL::ALL-ARGS-P S::C-SET-PACKAGE-NAME SYSTEM::DOUBLE
+   PCL::ALL-ARGS-P CSTRUCT::C-SET-PACKAGE-NAME SYSTEM::DOUBLE
    PCL::STANDARD-GENERIC-FUNCTION-P PCL::STANDARD-READER-METHOD-P
    PCL::STANDARD-METHOD-P PCL::*PORT+DNAME-LIST* PCL::DISPATCH-CACHE
    PCL::|SYSTEM:S-DATA SLOT0| PCL::GOLD-PATCHES PCL::FUNCTION-FUNCALL
    PCL::ALL-CLASS-LISTS PCL::EFFECTIVE-METHOD COMMON-LISP::LAMBDA
-   S::C-PATHNAME-TYPE COMMON-LISP::MAKE-SYNONYM-STREAM
+   CSTRUCT::C-PATHNAME-TYPE COMMON-LISP::MAKE-SYNONYM-STREAM
    PCL::*INITFUNCTIONS* PCL::CLASS-EQ
    PCL::CLASS-APPLICABLE-USING-CLASS-P COMMON-LISP::LISTP PCL::SUBCLASS
    COMMON-LISP::TERPRI COMMON-LISP::SATISFIES
@@ -2528,9 +2532,9 @@
    PCL::MAKE-BUILT-IN-CLASS-SUBS PCL::CHECK-WRAPPER-VALIDITY
    PCL::WRAPPER-REF PCL::NOT-BEST-P PCL::*DEFAULT-INITARGS-FLAG*
    COMMON-LISP::FIRST PCL::PARSE-SPEC COMMON-LISP::COMPLEX
-   S::C-ADJVECTOR-FILLP S::C-PATHNAME-NAME COMMON-LISP::UNTRACE
-   PCL::GMAKUNBOUND COMMON-LISP::FMAKUNBOUND PCL::CLOE
-   PCL::CACHE-MISS-VALUES PCL::N-N- PCL::FAST-METHOD-CALL-
+   CSTRUCT::C-ADJVECTOR-FILLP CSTRUCT::C-PATHNAME-NAME
+   COMMON-LISP::UNTRACE PCL::GMAKUNBOUND COMMON-LISP::FMAKUNBOUND
+   PCL::CLOE PCL::CACHE-MISS-VALUES PCL::N-N- PCL::FAST-METHOD-CALL-
    PCL::COMPUTE-APPLICABLE-METHODS-EMF
    PCL::FIRST-WRAPPER-CACHE-NUMBER-INDEX PCL::FALSE-CASE-P
    PCL::*IN-PRECOMPUTE-EFFECTIVE-METHODS-P*
@@ -2557,7 +2561,7 @@
    PCL::NO-PRIMARY-METHOD
    PCL::|(COMBINED-METHOD COMPUTE-EFFECTIVE-METHOD)|
    COMMON-LISP::DO-SYMBOLS COMMON-LISP::*ERROR-OUTPUT*
-   PCL::NOTE-PV-TABLE-REFERENCE S::C-
+   PCL::NOTE-PV-TABLE-REFERENCE CSTRUCT::C-
    PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION PCL::INITIALIZE-INFO-P
    COMMON-LISP::>= PCL::LIMIT-FN PCL::MAKE-DIRECT-SLOTD COMMON-LISP::<=
    PCL::MAKE-FAST-INSTANCE-BOUNDP PCL::NO-SLOT PCL::CMU
@@ -2572,34 +2576,36 @@
    PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY PCL::W-T
    PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P
    PCL::NUMBER-REQUIRED-ARGUMENTS PCL::FROB-COMBINED-METHOD-ARGS
-   PCL::HT-VALUE PCL::*MF2* PCL::S-DATA S::C-SET-SPICE-DUMMY PCL::K-T
-   PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::GF-CLASSES-TO-DO PCL::CPD
-   PCL::CONSTANT-SYMBOL-P PCL::*MF1* PCL::DEFAULT-METHOD-INITARGS
-   PCL::STRUCTURE-WRAPPER PCL::EARLY-COLLECT-INHERITANCE PCL::OLD-CACHE
+   PCL::HT-VALUE PCL::*MF2* PCL::S-DATA CSTRUCT::C-SET-SPICE-DUMMY
+   PCL::K-T PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::GF-CLASSES-TO-DO
+   PCL::CPD PCL::CONSTANT-SYMBOL-P PCL::*MF1*
+   PCL::DEFAULT-METHOD-INITARGS PCL::STRUCTURE-WRAPPER
+   PCL::EARLY-COLLECT-INHERITANCE PCL::OLD-CACHE
    PCL::MAKE-ACCESSOR-TABLE COMMON-LISP::WITH-CONDITION-RESTARTS
    PCL::ONE-CLASS-P PCL::*THE-ESLOTD-FUNCALLABLE-STANDARD-CLASS-SLOTS*
    PCL::*THE-ESLOTD-STANDARD-CLASS-SLOTS* PCL::*CLASS-EXPORTS*
    PCL::*DESTRUCTURE-VARS* PCL::INVALID PCL::GET-CACHE PCL::NEW-CACHE
    PCL::PV-CACHE-LIMIT-FN PCL::INITIAL-CLASSES-AND-WRAPPERS
-   S::C-ARRAY-ADJUSTABLE PCL::MAP-CACHE PCL::FLAGS
+   CSTRUCT::C-ARRAY-ADJUSTABLE PCL::MAP-CACHE PCL::FLAGS
    PCL::SLOT-CLASS-WRAPPER PCL::PV-BINDING PCL::DISPATCH-P
    PCL::DISPATCH- PCL::C-A-M-EMF PCL::NMS PCL::MT-TAIL
    PCL::*DFUN-CONSTRUCTORS* PCL::*STRUCTURE-TYPEP-COST*
    PCL::CACHE-MISS-VALUES-INTERNAL PCL::CHECK-INITARGS-VALUES
    PCL::.CALL-METHOD. PCL::OVERFLOW PCL::N-N-CACHE
-   PCL::MUTATE-SLOTS-AND-CALLS S::C-ARRAY-WRITABLE
+   PCL::MUTATE-SLOTS-AND-CALLS CSTRUCT::C-ARRAY-WRITABLE
    PCL::DEFAULT-STRUCTUREP PCL::DECLARATIONS PCL::FIND-CLASS-CELL-CLASS
    PCL::ADD-METHOD-DECLARATIONS PCL::UNPARSE COMMON-LISP::REMPROP
    COMMON-LISP::LIST* COMMON-LISP::LONG-SITE-NAME COMMON-LISP::PACKAGEP
    PCL::*BUILT-IN-OR-STRUCTURE-WRAPPER-TABLE*
-   COMMON-LISP::UNBOUND-VARIABLE COMMON-LISP::LOGIOR S::C-SYMBOL-PAD3
-   COMMON-LISP::INTERNAL-TIME-UNITS-PER-SECOND PCL::ENTRY-IN-CACHE-P
-   PCL::MAKE-ARG-INFO PCL::DEFAULT-METHOD-ONLY-DFUN-INFO
-   PCL::MAYBE-CHECK-CACHE PCL::INVALID-QUALIFIERS PCL::TYPES
-   PCL::EXPAND-SHORT-DEFCOMBIN PCL::GET-CACHE-FROM-CACHE PCL::LUCID-LOW
-   PCL::ONE-INDEX PCL::ONE-INDEX- S::C-SYMBOL-PAD2 PCL::ALL-INDEX
-   S::C-SET-MATRIX-DIMS COMMON-LISP::CALL-ARGUMENTS-LIMIT
-   PCL::CLASS-SLOT-P-CELL COMMON-LISP::APROPOS S::C-FUNCTION-ENV
+   COMMON-LISP::UNBOUND-VARIABLE COMMON-LISP::LOGIOR
+   CSTRUCT::C-SYMBOL-PAD3 COMMON-LISP::INTERNAL-TIME-UNITS-PER-SECOND
+   PCL::ENTRY-IN-CACHE-P PCL::MAKE-ARG-INFO
+   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO PCL::MAYBE-CHECK-CACHE
+   PCL::INVALID-QUALIFIERS PCL::TYPES PCL::EXPAND-SHORT-DEFCOMBIN
+   PCL::GET-CACHE-FROM-CACHE PCL::LUCID-LOW PCL::ONE-INDEX
+   PCL::ONE-INDEX- CSTRUCT::C-SYMBOL-PAD2 PCL::ALL-INDEX
+   CSTRUCT::C-SET-MATRIX-DIMS COMMON-LISP::CALL-ARGUMENTS-LIMIT
+   PCL::CLASS-SLOT-P-CELL COMMON-LISP::APROPOS CSTRUCT::C-FUNCTION-ENV
    COMMON-LISP::TYPEP COMMON-LISP::DPB PCL::PROTOTYPE PCL::SIZE
    COMMON-LISP::CHECK-TYPE PCL::PYRAMID PCL::PARAM-INDEX
    PCL::FUNCALLABLE-INSTANCE-DATA-1 PCL::MAP-INDEX PCL::GCLISP
@@ -2608,18 +2614,19 @@
    COMMON-LISP::*DEFAULT-PATHNAME-DEFAULTS*
    PCL::RESET-INITIALIZE-INFO-INTERNAL PCL::QUALIFIER-CHECK-RUNTIME
    PCL::GATHERER PCL::DEFINITION-SOURCE-MIXIN PCL::CLASS1 PCL::SNL
-   S::FUNCTION-ENV COMMON-LISP::NINTH PCL::MAKE-TYPE-PREDICATE-NAME
-   PCL::FINISH PCL::ARGUMENT-PRECEDENCE-ORDER-P PCL::*ASV-READERS*
+   CSTRUCT::FUNCTION-ENV COMMON-LISP::NINTH
+   PCL::MAKE-TYPE-PREDICATE-NAME PCL::FINISH
+   PCL::ARGUMENT-PRECEDENCE-ORDER-P PCL::*ASV-READERS*
    PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::SLOT-CLASS-SIMPLE-TYPEP-FN
    PCL::PROTO-GENERIC-FUNCTION PCL::GF-LL-NOPT PCL::COMPUTE-PRECEDENCE
    PCL::STRUCTURE-SLOT-DESCRIPTION PCL::STRUCTURE-SLOTD-READER-FUNCTION
    PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::STRUCTURE-SLOT-DEFINITION
    PCL::EQ-P COMMON-LISP::THROW PCL::|PCL::MODULE class predicate|
    PCL::VALUE-REG PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::SC1
-   PCL::ALL-SAME-P S::C-SET-T-CFW
+   PCL::ALL-SAME-P CSTRUCT::C-SET-T-CFW
    PCL::|PCL::ONE-INDEX-DFUN-INFO class predicate|
    PCL::GF-FAST-METHOD-FUNCTION-P COMMON-LISP::READTABLE-CASE
-   PCL::PLACE S::C-CFDATA-FILLP PCL::*FGENS* PCL::STORE-FGEN
+   PCL::PLACE CSTRUCT::C-CFDATA-FILLP PCL::*FGENS* PCL::STORE-FGEN
    COMMON-LISP::*LOAD-TRUENAME* PCL::TRANSFORMATIONS PCL::DASHES-P
    COMMON-LISP::DEFPARAMETER PCL::DEFAULT-CONSTANTP PCL::NOPTIONAL
    COMMON-LISP::&OPTIONAL PCL::EXTRA PCL::FUNCTION-NAMES
@@ -2630,9 +2637,9 @@
    PCL::*SLOT-NAME-LISTS-OUTER* COMMON-LISP::FUNCTION-LAMBDA-EXPRESSION
    PCL::.METHODS. COMMON-LISP::DOLIST PCL::SPECL-CPL
    PCL::|(WRITER SLOTS)| PCL::BINARY PCL::SKIP-DFUN-UPDATE-P
-   S::C-FIXNUM-DOUBLE-== S::C-FCOMPLEX-FCOMPLEX-==
-   S::C-FCOMPLEX-DCOMPLEX-== S::C-DCOMPLEX-FCOMPLEX-==
-   S::C-DCOMPLEX-DCOMPLEX-== PCL::MODULE- COMMON-LISP::*PACKAGE*
+   CSTRUCT::C-FIXNUM-DOUBLE-== CSTRUCT::C-FCOMPLEX-FCOMPLEX-==
+   CSTRUCT::C-FCOMPLEX-DCOMPLEX-== CSTRUCT::C-DCOMPLEX-FCOMPLEX-==
+   CSTRUCT::C-DCOMPLEX-DCOMPLEX-== PCL::MODULE- COMMON-LISP::*PACKAGE*
    PCL::USE-CONSTANT-VALUE-DFUN-P PCL::PL
    PCL::|PCL::ONE-CLASS class predicate| PCL::COPY-TWO-CLASS PCL::LINES
    COMMON-LISP::WILD-PATHNAME-P COMMON-LISP::IGNORABLE
@@ -2644,72 +2651,98 @@
    PCL::STRUCTURE-SLOTD-INIT-FORM COMMON-LISP::STRUCTURE-OBJECT
    COMMON-LISP::WITH-COMPILATION-UNIT PCL::CL
    PCL::STRUCTURE-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::WRAPPER-BINDINGS
-   S::C-FCOMPLEX-FLOAT-== S::C-DCOMPLEX-FLOAT-== S::+KS+
-   PCL::*BEING-LOADED* PCL::TO-LINE PCL::CACHE-MASK PCL::LINE-VALID-P
-   WALKER::*VARIABLE-DECLARATIONS* PCL::ONE-CLASS-CACHE
-   PCL::MAKE-EQL-PREDICATE SYSTEM::<< S::HASHTABLE-SELF
-   PCL::|(WRITER OBJECT)| PCL::|(WRITER TYPE)|
+   CSTRUCT::C-FCOMPLEX-FLOAT-== CSTRUCT::C-DCOMPLEX-FLOAT-==
+   CSTRUCT::+KS+ PCL::*BEING-LOADED* PCL::TO-LINE PCL::CACHE-MASK
+   PCL::LINE-VALID-P WALKER::*VARIABLE-DECLARATIONS*
+   PCL::ONE-CLASS-CACHE PCL::MAKE-EQL-PREDICATE SYSTEM::<<
+   CSTRUCT::HASHTABLE-SELF PCL::|(WRITER OBJECT)| PCL::|(WRITER TYPE)|
    PCL::EXPAND-TIME-VAL-FORMS PCL::ENTRY-WRAPPERS PCL::NEW-TABLE-TABLE
-   COMMON-LISP::PACKAGE-ERROR-PACKAGE S::C-SET-T-MDIM
+   COMMON-LISP::PACKAGE-ERROR-PACKAGE CSTRUCT::C-SET-T-MDIM
    PCL::CLASS-SLOT-VALUE COMMON-LISP::FLET
    PCL::*STANDARD-METHOD-COMBINATION* PCL::UNSUPPLIED PCL::TIMES
    COMMON-LISP::WITH-PACKAGE-ITERATOR PCL::GET-METHOD-FUNCTION-PV-CELL
    PCL::IBCL-PATCHES PCL::*UNSPECIFIC-ARG* PCL::*COMPILER-PRESENT-P*
-   PCL::|(WRITER CLASS)| S::C-SET-CFDATA-FILLP PCL::EFFECTIVE-P
+   PCL::|(WRITER CLASS)| CSTRUCT::C-SET-CFDATA-FILLP PCL::EFFECTIVE-P
    PCL::*FEGF-DEBUG-P* PCL::|INITIALIZE-INFO SLOT9|
    PCL::EMIT-CHECKING-OR-CACHING-FUNCTION
    PCL::*VARIABLE-DECLARATIONS-WITH-ARGUMENT*
    PCL::*VARIABLE-DECLARATIONS-WITHOUT-ARGUMENT* PCL::*THE-PCL-PACKAGE*
-   ITERATE::GATHER PCL::INITARG-ERROR S::C-SET-ARRAY-HASFILLP
+   ITERATE::GATHER PCL::INITARG-ERROR CSTRUCT::C-SET-ARRAY-HASFILLP
    COMMON-LISP::MOD PCL::SUPERCLASS
    PCL::*COMPUTE-STD-CPL-CLASS->ENTRY-TABLE-SIZE* PCL::*SGF-SLOTS-INIT*
    PCL::VECTORIZING COMMON-LISP::ELT PCL::BOD
    SYSTEM::NON-NEGATIVE-FIXNUM COMMON-LISP::MACHINE-INSTANCE
-   S::C-SET-STREAM-INT PCL::MAKE-TRANSFORMATIONS PCL::FN-LAMBDA
+   CSTRUCT::C-SET-STREAM-INT PCL::MAKE-TRANSFORMATIONS PCL::FN-LAMBDA
    PCL::|INITIALIZE-INFO SLOT8| COMMON-LISP::HANDLER-CASE
-   S::C-PATHNAME-DIRECTORY COMMON-LISP::REMOVE PCL::GENERA-LOW
+   CSTRUCT::C-PATHNAME-DIRECTORY COMMON-LISP::REMOVE PCL::GENERA-LOW
    COMMON-LISP::FLOAT-SIGN PCL::MLOOKUP PCL::*EVAL-WHEN-COMPILE*
    PCL::DEFAULT-INITARGS COMMON-LISP::LOGANDC1
    PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::STRUCTURE-TYPE-P
-   COMMON-LISP::COERCE S::C-CFDATA-SIZE PCL::TYPE2
+   COMMON-LISP::COERCE CSTRUCT::C-CFDATA-SIZE PCL::TYPE2
    PCL::MODULE-RECOMP-REASONS PCL::NO-METHODS-P PCL::TYPE1 PCL::DO-IF
-   PCL::N-N S::C-FIXNUM-FIXNUM-== PCL::COMPLETE PCL::FILES
+   PCL::N-N CSTRUCT::C-FIXNUM-FIXNUM-== PCL::COMPLETE PCL::FILES
    PCL::MAKE-FINAL-DFUN PCL::|INITIALIZE-INFO SLOT7|
    PCL::CONSTANT-VALUE-MISS PCL::PLS PCL::DOCUMENTATION-MIXIN
-   COMMON-LISP::PACKAGE-NICKNAMES S::C-HASHTABLE-MAX_ENT PCL::LOC
+   COMMON-LISP::PACKAGE-NICKNAMES CSTRUCT::C-HASHTABLE-MAX_ENT PCL::LOC
    COMMON-LISP::FIND-PACKAGE PCL::|PCL::SLOT-OBJECT class predicate|
    PCL::DOC PCL::UPDATE-SLOT-VALUE-GF-INFO PCL::..SLOT-UNBOUND..
    PCL::GCL_PCL_IMPL_LOW COMMON-LISP::LIST PCL::DEFINITION-SOURCE
    PCL::INNER-RESULT. PCL::|INITIALIZE-INFO SLOT6| PCL::WITH-HASH-TABLE
    PCL::MISS PCL::|(WRITER NAME)| COMMON-LISP::UNEXPORT
    COMMON-LISP::LOGXOR PCL::|PCL::INITIALIZE-INFO class predicate|
-   PCL::SAUT-NOT-CLASS-EQ COMMON-LISP::BIT-ANDC1 S::C-FUNCTION-SELF
-   PCL::CLASS1-SUB PCL::OSLOTS PCL::WRAPPER PCL::DEFINITION-BEFORE-PCL
-   S::C-FIXNUM-FIXNUM-> PCL::FUNCTION-RETURNING-NIL
-   PCL::TYPE+COUNT+SIZES COMMON-LISP::ARRAY-RANK-LIMIT PCL::GFSPEC
-   S::C-STRUCTURE-SELF PCL::ERROR-P PCL::*NON-BUILT-IN-TYPEP-COST*
+   PCL::SAUT-NOT-CLASS-EQ COMMON-LISP::BIT-ANDC1
+   CSTRUCT::C-FUNCTION-SELF PCL::CLASS1-SUB PCL::OSLOTS PCL::WRAPPER
+   PCL::DEFINITION-BEFORE-PCL CSTRUCT::C-FIXNUM-FIXNUM->
+   PCL::FUNCTION-RETURNING-NIL PCL::TYPE+COUNT+SIZES
+   COMMON-LISP::ARRAY-RANK-LIMIT PCL::GFSPEC CSTRUCT::C-STRUCTURE-SELF
+   PCL::ERROR-P PCL::*NON-BUILT-IN-TYPEP-COST*
    PCL::|INITIALIZE-INFO SLOT5| PCL::STRUCTURE-SLOTD-TYPE
-   PCL::*OPTIMIZE-ASV-FUNCALL-P* S::C-CFDATA-SELF PCL::QUALIFIERS
+   PCL::*OPTIMIZE-ASV-FUNCALL-P* CSTRUCT::C-CFDATA-SELF PCL::QUALIFIERS
    PCL::DEFAULT-METHOD-ONLY-CACHE PCL::|(READER SLOTS)|
-   S::C-FIXNUM-FLOAT-> PCL::SPECIFIER COMMON-LISP::POSITION-IF-NOT
-   PCL::VALID-KEYS COMMON-LISP::STYLE-WARNING PCL::LOAD-LONG-DEFCOMBIN
-   PCL::RI-VALID-P PCL::ADD-SLOT-ACCESSORS PCL::NSLOTS PCL::SEPARATE-P
+   CSTRUCT::C-FIXNUM-FLOAT-> PCL::SPECIFIER
+   COMMON-LISP::POSITION-IF-NOT PCL::VALID-KEYS
+   COMMON-LISP::STYLE-WARNING PCL::LOAD-LONG-DEFCOMBIN PCL::RI-VALID-P
+   PCL::ADD-SLOT-ACCESSORS PCL::NSLOTS PCL::SEPARATE-P
    PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME PCL::ACCESSOR-SLOT-BOUNDP
    PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|
    PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| PCL::WITH
-   S::C-T-MELTTYPE PCL::|INITIALIZE-INFO SLOT4| PCL::|(READER PLIST)|
-   PCL::WRAPPER-CLASS* PCL::STRUCTURE-SVUC-METHOD PCL::COUNT-DFUN
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION2
+   CSTRUCT::C-T-MELTTYPE PCL::|INITIALIZE-INFO SLOT4|
+   PCL::|(READER PLIST)| PCL::WRAPPER-CLASS* PCL::STRUCTURE-SVUC-METHOD
+   PCL::COUNT-DFUN PCL::GET-SECONDARY-DISPATCH-FUNCTION2
    COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM
    COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM
    PCL::REAL-MAKE-METHOD-LAMBDA PCL::ARG-INFO-LAMBDA-LIST
-   S::C-SET-CFDATA-SIZE PCL::CLASS-WRAPPER PCL::|(READER OBJECT)|
+   CSTRUCT::C-SET-CFDATA-SIZE PCL::CLASS-WRAPPER PCL::|(READER OBJECT)|
    PCL::|(READER TYPE)| PCL::STRUCTURE-SLOTD-NAME PCL::*TRACED-METHODS*
-   COMMON-LISP::UNUSE-PACKAGE S::C-SET-ARRAY-ELTSIZE
+   COMMON-LISP::UNUSE-PACKAGE CSTRUCT::C-SET-ARRAY-ELTSIZE
    COMMON-LISP::PRINT-NOT-READABLE PCL::LEGAL-SLOT-NAME-P
    PCL::|INITIALIZE-INFO SLOT3| PCL::XEROX-PATCHES
    PCL::LIST-LARGE-CACHES PCL::INVALID-WRAPPER-P
-   S::C-SET-STRUCTURE-SELF
+   CSTRUCT::C-SET-STRUCTURE-SELF
+   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
    PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
    PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
    PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
@@ -2773,30 +2806,6 @@
    PCL::|(FAST-METHOD DOCUMENTATION (T T))|
    PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
    PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
    PCL::GET-SECONDARY-DISPATCH-FUNCTION1 PCL::EARLY-MAKE-A-METHOD
    PCL::IOA COMMON-LISP::VECTOR-POP PCL::OPERATE-ON-SYSTEM
    PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::INITARGS-FORM
@@ -2804,15 +2813,15 @@
    COMMON-LISP::BYTE PCL::WHOLE PCL::|(READER CLASS)|
    PCL::SHOW-DFUN-CONSTRUCTORS COMMON-LISP::HASH-TABLE-SIZE
    PCL::|INITIALIZE-INFO SLOT2| PCL::ARG-INFO-APPLYP
-   COMMON-LISP::KEYWORD SYSTEM::C-FIXNUM-== S::C-SET-STREAM-FP
+   COMMON-LISP::KEYWORD SYSTEM::C-FIXNUM-== CSTRUCT::C-SET-STREAM-FP
    PCL::INITARGS-TAIL PCL::MAKE-CLASS-PRECEDENCE-DESCRIPTION
    PCL::REL-8-PATCHES COMMON-LISP::DIGIT-CHAR
    PCL::MAKE-FORWARD-REFERENCED-CLASS-P PCL::CLASS-EQ-WRAPPER
    PCL::GET-SLOTS-OR-NIL PCL::SLOT-VALUE-OR-DEFAULT
    PCL::REMOVE-SLOT-ACCESSORS PCL::|INITIALIZE-INFO SLOT1|
-   S::C-SET-CFDATA-SELF PCL::AKEY COMMON-LISP::LENGTH
+   CSTRUCT::C-SET-CFDATA-SELF PCL::AKEY COMMON-LISP::LENGTH
    PCL::MAKE-DFUN-LAMBDA-LIST PCL::NEW-TYPE PCL::CMU-LOW PCL::OK
-   S::C-SET-ARRAY-SELF PCL::PV-TABLES PCL::GCL_PCL_FAST_INIT
+   CSTRUCT::C-SET-ARRAY-SELF PCL::PV-TABLES PCL::GCL_PCL_FAST_INIT
    PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::KLIST-TAIL
    PCL::ALIST-TAIL PCL::*DEFCLASS-TIMES*
    PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
@@ -2823,10 +2832,10 @@
    PCL::WRAPPER-CACHE-NUMBER-VECTOR
    PCL::LONG-METHOD-COMBINATION-ARGUMENTS-LAMBDA-LIST
    COMMON-LISP::*READ-BASE* COMMON-LISP::CHAR-CODE-LIMIT
-   PCL::SYMBOL-OR-CONS-LESSP PCL::*PCL-PROCLAIM* S::C-T-MADJUSTABLE
-   PCL::EMIT-CHECKING-OR-CACHING PCL::MAKE-EARLY-GF
-   PCL::CLASS-EQ-SPECIALIZER-WRAPPER COMMON-LISP::1+
-   PCL::WRAPPER-CACHE-NUMBER S::C-FUNCTION-ARGD
+   PCL::SYMBOL-OR-CONS-LESSP PCL::*PCL-PROCLAIM*
+   CSTRUCT::C-T-MADJUSTABLE PCL::EMIT-CHECKING-OR-CACHING
+   PCL::MAKE-EARLY-GF PCL::CLASS-EQ-SPECIALIZER-WRAPPER COMMON-LISP::1+
+   PCL::WRAPPER-CACHE-NUMBER CSTRUCT::C-FUNCTION-ARGD
    PCL::CONSTANT-VALUE-DFUN-INFO PCL::*DFUN-ARG-SYMBOLS*
    PCL::LOCATION-RESERVED-P COMMON-LISP::++
    PCL::STRUCTURE-DIRECT-SLOT-DEFINITION COMMON-LISP::*GENSYM-COUNTER*
@@ -2835,7 +2844,7 @@
    PCL::SET-CLASS-SLOT-VALUE-1 PCL::ENVIRONMENT
    PCL::STRUCTURE-CLASS-WRAPPER PCL::ALL-APPLICABLE PCL::*FIND-CLASS*
    PCL::MAYBE-OPTIMIZE-READER COMMON-LISP::BYTE-SIZE PCL::PYR-LOW
-   PCL::DESCRIBE-PACKAGE PCL::CM-ARGS S::C-SET-T-EMF
+   PCL::DESCRIBE-PACKAGE PCL::CM-ARGS CSTRUCT::C-SET-T-EMF
    PCL::ALL-APPLICABLE-AND-SORTED-P PCL::TYPE-FUNCTION
    PCL::SUPPLIED-SUPERS COMMON-LISP::FIFTH PCL::DO-CLASS PCL::GF-ARGS
    PCL::MAKE-CHECKING-OR-CACHING-FUNCTION-LIST PCL::WRAPPERS
@@ -2846,18 +2855,20 @@
    COMMON-LISP::AND PCL::GF-CLASS COMMON-LISP::STABLE-SORT
    PCL::HP-HPLABS COMMON-LISP::CHAR-NOT-LESSP
    PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS PCL::GF-SPEC
-   S::C-SET-CONS-CDR PCL::FLAG PCL::PENDING-POPS PCL::WRAPPER-CACHE-NO
+   CSTRUCT::C-SET-CONS-CDR PCL::FLAG PCL::PENDING-POPS
+   PCL::WRAPPER-CACHE-NO
    PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN
-   COMMON-LISP::BIT-EQV COMMON-LISP::CHAR/= S::C-SET-STREAM-MODE
+   COMMON-LISP::BIT-EQV COMMON-LISP::CHAR/= CSTRUCT::C-SET-STREAM-MODE
    PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN COMMON-LISP::CHAR-UPCASE
-   PCL::|PCL::CACHE class predicate| S::C-SET-ARRAY-ELTMODE
-   COMMON-LISP::PPRINT-TAB S::C-SET-CONS-CAR S::C-SET-ARRAY-WRITABLE
-   S::C-SET-ARRAY-ADJUSTABLE PCL::INITIAL-DISPATCH-
-   PCL::INITIALIZE-INFO- PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER
-   PCL::FROM-CACHE-VECTOR PCL::MAKE-EARLY-ACCESSOR
-   PCL::CONSTANT-VALUE-P PCL::ECD-SUPERCLASS-NAMES COMMON-LISP::BIT-NOT
-   COMMON-LISP::IGNORE PCL::INC PCL::GCL_PCL_GENERIC_FUNCTIONS
-   COMMON-LISP::BIT-XOR ITERATE::INTERVAL
+   PCL::|PCL::CACHE class predicate| CSTRUCT::C-SET-ARRAY-ELTMODE
+   COMMON-LISP::PPRINT-TAB CSTRUCT::C-SET-CONS-CAR
+   CSTRUCT::C-SET-ARRAY-WRITABLE CSTRUCT::C-SET-ARRAY-ADJUSTABLE
+   PCL::INITIAL-DISPATCH- PCL::INITIALIZE-INFO-
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER PCL::FROM-CACHE-VECTOR
+   PCL::MAKE-EARLY-ACCESSOR PCL::CONSTANT-VALUE-P
+   PCL::ECD-SUPERCLASS-NAMES COMMON-LISP::BIT-NOT COMMON-LISP::IGNORE
+   PCL::INC PCL::GCL_PCL_GENERIC_FUNCTIONS COMMON-LISP::BIT-XOR
+   ITERATE::INTERVAL
    PCL::STRUCTURE-DIRECT-SLOT-DEFINITION-SIMPLE-TYPEP-FN
    COMMON-LISP::MAKE-PACKAGE PCL::FREE-CACHE-VECTOR
    PCL::PRECOMPILE-RANDOM-CODE-SEGMENTS PCL::LOCATION-VALID-P
@@ -2872,7 +2883,7 @@
    COMMON-LISP::TYPE COMMON-LISP::PPRINT-POP PCL::GF-TABLE
    PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-MACRO
    PCL::CALL-NEXT-METHOD-BODY PCL::STRUCTURE-CLASS-SIMPLE-TYPEP-FN
-   PCL::FAST-INSTANCE-BOUNDP PCL::GENERIC-FUNCTION-NAME-P S::*INT
+   PCL::FAST-INSTANCE-BOUNDP PCL::GENERIC-FUNCTION-NAME-P CSTRUCT::*INT
    PCL::LOCATION-VALUE PCL::COPY-N-N COMMON-LISP::DEFPACKAGE
    PCL::APPLICABLE PCL::ACCESSOR-MISS
    COMMON-LISP::WITH-OUTPUT-TO-STRING PCL::CLASS-KEY PCL::SLOTS-KEY
@@ -2880,7 +2891,7 @@
    COMMON-LISP::RETURN PCL::.CALL. PCL::COPY-CONSTANT-VALUE
    PCL::LONG-METHOD-COMBINATION-FUNCTION PCL::LONG-METHOD-COMBINATION
    PCL::*THE-WRAPPER-OF-FLOAT* PCL::|(BOUNDP INITARGS)| PCL::FOUND-P
-   COMMON-LISP::SIGNUM PCL::*ACCESSORS* S::C-SET-STRUCTURE-DEF
+   COMMON-LISP::SIGNUM PCL::*ACCESSORS* CSTRUCT::C-SET-STRUCTURE-DEF
    PCL::CHECK-METH PCL::*THE-WRAPPER-OF-CONS* PCL::ACCESSOR-SLOT-VALUE
    PCL::ASV-FUNCALL SYSTEM::TP7 COMMON-LISP::FIXNUM
    PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P PCL::MEC-ALL-CLASSES-INTERNAL
@@ -2896,9 +2907,10 @@
    PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
    PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
    PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
-   PCL::*THE-CLASS-SPECIALIZER* S::LISP-TYPE PCL::DFUN-TYPE
+   PCL::*THE-CLASS-SPECIALIZER* CSTRUCT::LISP-TYPE PCL::DFUN-TYPE
    PCL::IMPROPER-LIST-HANDLER PCL::*SLOT-ACCESSOR-NAME-PACKAGE*
-   PCL::|CACHE SLOT11| S::C-HASHTABLE-RHSIZE S::C-HASHTABLE-SIZE
+   PCL::|CACHE SLOT11| CSTRUCT::C-HASHTABLE-RHSIZE
+   CSTRUCT::C-HASHTABLE-SIZE
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DECLARATIONS)|
@@ -2967,13 +2979,13 @@
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
-   PCL::*PREVIOUS-NWRAPPERS* S::C-DOUBLE-FLOAT-==
+   PCL::*PREVIOUS-NWRAPPERS* CSTRUCT::C-DOUBLE-FLOAT-==
    PCL::|(BOUNDP ARG-INFO)| ITERATE::WHILE PCL::*THE-WRAPPER-OF-REAL*
    PCL::KIND PCL::EMIT-ONE-CLASS-WRITER COMMON-LISP::COMPILED-FUNCTION
-   S::C-READTABLE-SELF PCL::|(BOUNDP OPERATOR)|
+   CSTRUCT::C-READTABLE-SELF PCL::|(BOUNDP OPERATOR)|
    PCL::COMPUTE-STD-CPL-PHASE-1 PCL::UNPARSED-SPECIALIZERS
    COMMON-LISP::LISP-IMPLEMENTATION-VERSION PCL::OWNER
-   PCL::MAKE-MODULES PCL::CACHING-P S::C-HASHTABLE-SELF
+   PCL::MAKE-MODULES PCL::CACHING-P CSTRUCT::C-HASHTABLE-SELF
    COMMON-LISP::FIND PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-COMBINATION)|
@@ -2989,34 +3001,35 @@
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ALLOCATION)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFUNCTION)|
    PCL::*SECONDARY-DFUN-CALL-COST* PCL::MAKE-DFUN-ARG-LIST
-   PCL::*REVERT-INITIALIZE-INFO-P* S::C-SET-STREAM-FD
-   S::C-PACKAGE-SHADOWINGS PCL::*THE-WRAPPER-OF-STRING* SYSTEM::TP5
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::*REVERT-INITIALIZE-INFO-P* CSTRUCT::C-SET-STREAM-FD
+   CSTRUCT::C-PACKAGE-SHADOWINGS PCL::*THE-WRAPPER-OF-STRING*
+   SYSTEM::TP5 PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)| PCL::*BOOT-STATE*
    PCL::*SGF-DFUN-STATE-INDEX* PCL::CACHE-OWNER PCL::RESET-PCL-PACKAGE
    PCL::NEW-KEYS PCL::POSSIBLY-APPLICABLE COMMON-LISP::EXPT
    PCL::LIST-LARGE-CACHE PCL::.METHOD-COMBINATION.
    PCL::FORMAT-ARGUMENTS SYSTEM::C* PCL::*THE-CLASS-RATIONAL*
-   S::C-SET-READTABLE-SELF PCL::META-SPECIALIZER PCL::LOAD-DEFCLASS
-   PCL::TRUE-VALUE COMMON-LISP::FILL PCL::CACHED-SLOT-NAMES
-   PCL::ACCESSOR-NAMES COMMON-LISP::TIME PCL::THREAD
+   CSTRUCT::C-SET-READTABLE-SELF PCL::META-SPECIALIZER
+   PCL::LOAD-DEFCLASS PCL::TRUE-VALUE COMMON-LISP::FILL
+   PCL::CACHED-SLOT-NAMES PCL::ACCESSOR-NAMES COMMON-LISP::TIME
+   PCL::THREAD
    PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
    PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
    PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
    PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :DEFINITION-SOURCE :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
    PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION :FUNCTION :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
-   COMMON-LISP::COMPILER-MACRO-FUNCTION S::C-DOUBLE-DOUBLE->
+   COMMON-LISP::COMPILER-MACRO-FUNCTION CSTRUCT::C-DOUBLE-DOUBLE->
    PCL::METHOD-SYM PCL::NEW-NAME PCL::EMIT-ONE-CLASS-READER
    PCL::ORIG-METHODS COMMON-LISP::PRINT-UNREADABLE-OBJECT PCL::VALUEP
-   PCL::LINE-VALUE S::C-PATHNAME-NAMESTRING PCL::ARG-NUMBER
+   PCL::LINE-VALUE CSTRUCT::C-PATHNAME-NAMESTRING PCL::ARG-NUMBER
    PCL::DOCUMENTATION-P PCL::*THE-CLASS-NUMBER*
    COMMON-LISP::NSUBST-IF-NOT COMMON-LISP::** PCL::CYCLE
    PCL::CLASS-EQ-TEST PCL::*EMF-CALL-TRACE-SIZE*
    PCL::COMBINED-INITARGS-FORM-LIST PCL::ADD-WRITER-METHOD
    PCL::CONSTANT-VALUE-CACHE PCL::IMPROPER-LIST PCL::WRITER-NAMES
    PCL::NO-METHODS PCL::DO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
-   S::C-READTABLE-CASE PCL::METAOBJECT-SIMPLE-TYPEP-FN
+   CSTRUCT::C-READTABLE-CASE PCL::METAOBJECT-SIMPLE-TYPEP-FN
    PCL::DIRECT-SUPERCLASSES COMMON-LISP::READ-CHAR-NO-HANG
    PCL::*METHOD-FUNCTION-PLIST* PCL::FIELD-NUMBER
    PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::*THE-WRAPPER-OF-RANDOM-STATE*
@@ -3027,15 +3040,17 @@
    COMMON-LISP::NOTINLINE COMMON-LISP::IDENTITY
    PCL::|(SETF SLOT-DEFINITION-NAME)| PCL::GF-KEY/REST-P
    PCL::|(BOUNDP CLASS-EQ-SPECIALIZER)| PCL::CURRENT-CLASS
-   PCL::NEW-NLINES PCL::*THE-CLASS-SYMBOL* S::C-SET-READTABLE-CASE
-   PCL::.CACHE. PCL::ACCESSOR-SET-SLOT-VALUE
+   PCL::NEW-NLINES PCL::*THE-CLASS-SYMBOL*
+   CSTRUCT::C-SET-READTABLE-CASE PCL::.CACHE.
+   PCL::ACCESSOR-SET-SLOT-VALUE
    PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
    PCL::DEPENDENT-UPDATE-MIXIN-SIMPLE-TYPEP-FN PCL::*EMF-CALL-TRACE*
    PCL::NLINES COMMON-LISP::PPRINT-TABULAR COMMON-LISP::TRUNCATE
    COMMON-LISP::SYMBOL-VALUE PCL::PV-TABLE-LOOKUP PCL::.DFUN-REST-ARG.
    COMMON-LISP::BIT-ORC1 PCL::FILE
    PCL::|(BOUNDP DEFSTRUCT-ACCESSOR-SYMBOL)| PCL::NEXT-METHOD-P-BODY
-   S::C-FLOAT-FLOAT-> PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)|
+   CSTRUCT::C-FLOAT-FLOAT->
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-NAME)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)| PCL::MIF-KEY
@@ -3044,37 +3059,39 @@
    PCL::*THE-CLASS-STANDARD-READER-METHOD*
    PCL::*THE-CLASS-STANDARD-METHOD* PCL::*THE-CLASS-METHOD*
    PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD* COMMON-LISP::CHAR-DOWNCASE
-   S::C-STRUCTURE-DEF PCL::EXACT-CLASS-SPECIALIZER-SIMPLE-TYPEP-FN
-   PCL::DIRECT-SUBCLASSES PCL::CHECK-FUNCTION S::C-SET-RATIO-NUM
-   PCL::SORTED-CALLS PCL::*FREE-CACHE-VECTORS* PCL::WRITER-SYMBOL
-   PCL::SLOTS-TO-INSPECT PCL::FMC-FUNCALL PCL::EMF-FUNCALL SYSTEM::TP3
-   PCL::SMC PCL::PV-TABLE-SLOT-NAME-LISTS
+   CSTRUCT::C-STRUCTURE-DEF
+   PCL::EXACT-CLASS-SPECIALIZER-SIMPLE-TYPEP-FN PCL::DIRECT-SUBCLASSES
+   PCL::CHECK-FUNCTION CSTRUCT::C-SET-RATIO-NUM PCL::SORTED-CALLS
+   PCL::*FREE-CACHE-VECTORS* PCL::WRITER-SYMBOL PCL::SLOTS-TO-INSPECT
+   PCL::FMC-FUNCALL PCL::EMF-FUNCALL SYSTEM::TP3 PCL::SMC
+   PCL::PV-TABLE-SLOT-NAME-LISTS
    PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN
    PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN
    PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN PCL::MAKE-FINAL-CACHING-DFUN
    PCL::MAKE-FINAL-DISPATCH-DFUN PCL::MAKE-FINAL-CHECKING-DFUN
    PCL::MAKE-FINAL-ACCESSOR-DFUN PCL::MODULE-COMP-ENV
    PCL::MODULE-LOAD-ENV PCL::LOAD-DEFMETHOD-INTERNAL PCL::SETQS
-   PCL::NMC PCL::EMIT-MISS PCL::|(BOUNDP WRAPPER)| S::C-SET-FUNCTION-VV
-   PCL::*LAZY-DFUN-COMPUTE-P* PCL::SORT-METHODS
-   PCL::*THE-CLASS-READTABLE* PCL::*THE-CLASS-HASH-TABLE*
-   COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS PCL::COMPILE-FILTER
-   PCL::NEW-ICUI S::C-T-MDIM PCL::PV-TABLE-PV-SIZE PCL::ALLOCATE
-   COMMON-LISP::SYMBOL-PACKAGE PCL::MAKE-PROGN PCL::CONSTANT-VALUE
-   PCL::TO-CACHE PCL::LMF-PARAMS PCL::*EQ-CASE-TABLE-LIMIT*
-   PCL::COPY-INITIALIZE-INFO PCL::TESTS
-   PCL::REAL-METHOD-COMBINATION-ERROR S::C-HASHTABLE-CACHE PCL::GET-VAL
-   PCL::SET-VAL S::C-PATHNAME-DEVICE COMMON-LISP::SVREF
-   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::FIX PCL::CLASS-CONSTRUCTORS
-   PCL::PVREF PCL::INVOKE-FAST-METHOD-CALL PCL::{METHOD-QUALIFIER}*
-   PCL::FORMAT-ARGS PCL::FINISH-PUSHING-INITARGS
-   PCL::FORMAT-CYCLE-REASONS PCL::STD-MI-METH PCL::STD-SI-METH
-   PCL::STD-II-METH PCL::METHOD-GROUP-SPECIFIERS PCL::PROPERTY-LIST
+   PCL::NMC PCL::EMIT-MISS PCL::|(BOUNDP WRAPPER)|
+   CSTRUCT::C-SET-FUNCTION-VV PCL::*LAZY-DFUN-COMPUTE-P*
+   PCL::SORT-METHODS PCL::*THE-CLASS-READTABLE*
+   PCL::*THE-CLASS-HASH-TABLE* COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS
+   PCL::COMPILE-FILTER PCL::NEW-ICUI CSTRUCT::C-T-MDIM
+   PCL::PV-TABLE-PV-SIZE PCL::ALLOCATE COMMON-LISP::SYMBOL-PACKAGE
+   PCL::MAKE-PROGN PCL::CONSTANT-VALUE PCL::TO-CACHE PCL::LMF-PARAMS
+   PCL::*EQ-CASE-TABLE-LIMIT* PCL::COPY-INITIALIZE-INFO PCL::TESTS
+   PCL::REAL-METHOD-COMBINATION-ERROR CSTRUCT::C-HASHTABLE-CACHE
+   PCL::GET-VAL PCL::SET-VAL CSTRUCT::C-PATHNAME-DEVICE
+   COMMON-LISP::SVREF PCL::ACCESSOR-DFUN-INFO-CACHE PCL::FIX
+   PCL::CLASS-CONSTRUCTORS PCL::PVREF PCL::INVOKE-FAST-METHOD-CALL
+   PCL::{METHOD-QUALIFIER}* PCL::FORMAT-ARGS
+   PCL::FINISH-PUSHING-INITARGS PCL::FORMAT-CYCLE-REASONS
+   PCL::STD-MI-METH PCL::STD-SI-METH PCL::STD-II-METH
+   PCL::METHOD-GROUP-SPECIFIERS PCL::PROPERTY-LIST
    PCL::PV-TABLE-LOOKUP-PV-ARGS PCL::RESTP PCL::K+M
    PCL::MAKE-INSTANCE-FUNCTION-SIMPLE SYSTEM::TP2 PCL::GBOUNDP
    COMMON-LISP::FBOUNDP COMMON-LISP::BUTLAST
    COMMON-LISP::MOST-NEGATIVE-FIXNUM PCL::.APPLICABLE-METHODS.
-   PCL::ONCE-ONLY PCL::VAXLISP S::C-ARRAY-OFFSET
+   PCL::ONCE-ONLY PCL::VAXLISP CSTRUCT::C-ARRAY-OFFSET
    PCL::|PCL::DIRECT-SLOT-DEFINITION class predicate|
    PCL::NLINES-OR-CACHE-VECTOR PCL::MAKE-EFFECTIVE-METHOD-FUNCTION
    PCL::ORDER-SPECIALIZERS PCL::SIMPLE-LEXICAL-METHOD-FUNCTIONS
@@ -3083,25 +3100,26 @@
    COMMON-LISP::MOST-NEGATIVE-DOUBLE-FLOAT
    COMMON-LISP::MOST-NEGATIVE-LONG-FLOAT PCL::STRUCTURE-TYPE
    COMMON-LISP::FIND-RESTART PCL::WRAPPED-BODY
-   COMMON-LISP::INTERSECTION S::C-MATRIX-DIMS PCL::CLASS-FROM-TYPE
-   COMMON-LISP::SEVENTH COMMON-LISP::SET-PPRINT-DISPATCH
-   S::C-HASHTABLE-STATIC COMMON-LISP::DENOMINATOR
-   COMMON-LISP::CHAR-LESSP S::C-SET-RATIO-DEN PCL::DOLIST-CAREFULLY
-   PCL::RESTL COMMON-LISP::OUTPUT-STREAM-P S::C-PACKAGE-NICKNAMES
+   COMMON-LISP::INTERSECTION CSTRUCT::C-MATRIX-DIMS
+   PCL::CLASS-FROM-TYPE COMMON-LISP::SEVENTH
+   COMMON-LISP::SET-PPRINT-DISPATCH CSTRUCT::C-HASHTABLE-STATIC
+   COMMON-LISP::DENOMINATOR COMMON-LISP::CHAR-LESSP
+   CSTRUCT::C-SET-RATIO-DEN PCL::DOLIST-CAREFULLY PCL::RESTL
+   COMMON-LISP::OUTPUT-STREAM-P CSTRUCT::C-PACKAGE-NICKNAMES
    PCL::DEFINITION PCL::COMBINED-INITIALIZE-FUNCTION PCL::CACHE-NKEYS
    COMMON-LISP::INTERN PCL::CLASS1-SUBS COMMON-LISP::INVOKE-DEBUGGER
-   COMMON-LISP::MINUSP S::C-T-MRANK PCL::GCL_PCL_DEFCOMBIN
+   COMMON-LISP::MINUSP CSTRUCT::C-T-MRANK PCL::GCL_PCL_DEFCOMBIN
    PCL::NEW-DFUN-WRAPPERS-TAIL PCL::*INITIALIZE-INSTANCE-SIMPLE-ALIST*
    PCL::BIW COMMON-LISP::MAKE-TWO-WAY-STREAM PCL::UPDATE-GF-INFO
    PCL::STD-INSTANCE-SLOTS PCL::DIRECT-SLOT PCL::*ASV-WRITERS*
    PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER PCL::TRY-ONE-FILL
-   S::C-SET-FUNCTION-PLIST PCL::XEROX PCL::EQL-SPECIALIZER-OBJECT
+   CSTRUCT::C-SET-FUNCTION-PLIST PCL::XEROX PCL::EQL-SPECIALIZER-OBJECT
    COMMON-LISP::DYNAMIC-EXTENT PCL::.SHES-NOT-THERE.
    PCL::CACHED-RI-VALID-P COMMON-LISP::CONCATENATED-STREAM
-   PCL::UPDATE-INITIALIZE-INFO-CACHE S::C-DOUBLE-FCOMPLEX-==
-   S::C-DOUBLE-DCOMPLEX-== PCL::PROPER-EXTENSIONS
+   PCL::UPDATE-INITIALIZE-INFO-CACHE CSTRUCT::C-DOUBLE-FCOMPLEX-==
+   CSTRUCT::C-DOUBLE-DCOMPLEX-== PCL::PROPER-EXTENSIONS
    PCL::STD-INSTANCE-CLASS PCL::EXPAND-CACHE PCL::SYM2
-   COMMON-LISP::RESTART S::C-SET-T-W PCL::TRACE-EMF-CALL-INTERNAL
+   COMMON-LISP::RESTART CSTRUCT::C-SET-T-W PCL::TRACE-EMF-CALL-INTERNAL
    COMMON-LISP::LAMBDA-LIST-KEYWORDS SYSTEM::TP1
    PCL::INVOKE-METHOD-CALL PCL::ALLOCATE-FUNCALLABLE-INSTANCE-SLOTS
    PCL::*CACHE* PCL::SYM1 PCL::SLOT-DEFINITION-CLASS
@@ -3114,9 +3132,9 @@
    PCL::CALL-METHOD-LIST PCL::CLASS-METHOD-INITARGS
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::OFFSET)|
    PCL::WRAPPER-CACHE-NUMBER-VECTOR-REF PCL::CLASS-NAME-OF
-   S::C-SET-T-ST PCL::METHOD2 PCL::*ALL-PV-TABLE-LIST*
+   CSTRUCT::C-SET-T-ST PCL::METHOD2 PCL::*ALL-PV-TABLE-LIST*
    PCL::FSC-INSTANCE-SLOTS PCL::SORTER PCL::NEW-DEFINITION
-   S::C-STREAM-INT S::C-STREAM-FP PCL::OTYPE PCL::SUBFORM
+   CSTRUCT::C-STREAM-INT CSTRUCT::C-STREAM-FP PCL::OTYPE PCL::SUBFORM
    PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
    PCL::|(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
@@ -3150,16 +3168,17 @@
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-DESCRIPTIONS)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONSTRUCTORS)|
    PCL::UNCOMPILED COMMON-LISP::STRING-UPCASE
-   COMMON-LISP::STRING-DOWNCASE S::C-T-MHASFILLP PCL::GF-DFUN-INFO
-   PCL::POP-INTO
+   COMMON-LISP::STRING-DOWNCASE CSTRUCT::C-T-MHASFILLP
+   PCL::GF-DFUN-INFO PCL::POP-INTO
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::NO-EMIT)|
-   S::C-SET-T-M S::C-SET-T-MF COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE
-   PCL::NEW-FIELD SYSTEM::TP0 PCL::MAKE-PLIST COMMON-LISP::FTRUNCATE
-   PCL::METHOD1 PCL::TI PCL::SI PCL::MEMF-TEST-CONVERTER
-   PCL::OCLASS-SLOT-AND-VAL PCL::GATHER1 PCL::SET-MF-PROPERTY
-   COMMON-LISP::ARRAY-ELEMENT-TYPE COMMON-LISP::ALPHANUMERICP
-   COMMON-LISP::PI PCL::CONTEXT COMMON-LISP::MAP-INTO
-   PCL::EARLY-GF-METHODS PCL::MAKE-STRUCTURE-OBJECT PCL::LIST-PV
+   CSTRUCT::C-SET-T-M CSTRUCT::C-SET-T-MF
+   COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE PCL::NEW-FIELD SYSTEM::TP0
+   PCL::MAKE-PLIST COMMON-LISP::FTRUNCATE PCL::METHOD1 PCL::TI PCL::SI
+   PCL::MEMF-TEST-CONVERTER PCL::OCLASS-SLOT-AND-VAL PCL::GATHER1
+   PCL::SET-MF-PROPERTY COMMON-LISP::ARRAY-ELEMENT-TYPE
+   COMMON-LISP::ALPHANUMERICP COMMON-LISP::PI PCL::CONTEXT
+   COMMON-LISP::MAP-INTO PCL::EARLY-GF-METHODS
+   PCL::MAKE-STRUCTURE-OBJECT PCL::LIST-PV
    COMMON-LISP::ARITHMETIC-ERROR PCL::GET-FUNCTION-GENERATOR
    PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION ARGUMENTS-LAMBDA-LIST)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
@@ -3175,12 +3194,12 @@
    PCL::|(FAST-READER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
    PCL::|(FAST-READER-METHOD PLIST-MIXIN PLIST)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT PLIST)|
-   S::C-SET-STREAM-OBJECT1 PCL::FORWARD-CLASS PCL::SAUT-NOT-EQL
+   CSTRUCT::C-SET-STREAM-OBJECT1 PCL::FORWARD-CLASS PCL::SAUT-NOT-EQL
    COMMON-LISP::PROVIDE PCL::SLOT-REGS
    PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)| PCL::BY
-   S::C-ARRAY-RANK PCL::DI PCL::*DEFMETHOD-TIMES* PCL::IIS-BODY
-   PCL::DEFINE-INITIALIZE-INFO S::C-SET-CHARACTER-CODE
+   CSTRUCT::C-ARRAY-RANK PCL::DI PCL::*DEFMETHOD-TIMES* PCL::IIS-BODY
+   PCL::DEFINE-INITIALIZE-INFO CSTRUCT::C-SET-CHARACTER-CODE
    COMMON-LISP::PPRINT-EXIT-IF-LIST-EXHAUSTED PCL::TYPE-SPEC
    PCL::PV-OFFSET-LIST PCL::BEFORE
    PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFORM)|
@@ -3202,8 +3221,9 @@
    PCL::|(FAST-READER-METHOD SPECIALIZER TYPE)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
-   PCL::*SUBTYPEP PCL::EMF-TYPE S::C-SET-T-E S::C-SET-HASHTABLE-TEST
-   S::C-T-MWRITABLE PCL::CONVERTED PCL::STD-INSTANCE-WRAPPER
+   PCL::*SUBTYPEP PCL::EMF-TYPE CSTRUCT::C-SET-T-E
+   CSTRUCT::C-SET-HASHTABLE-TEST CSTRUCT::C-T-MWRITABLE PCL::CONVERTED
+   PCL::STD-INSTANCE-WRAPPER
    PCL::|(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
    PCL::|(FAST-READER-METHOD SLOT-DEFINITION READERS)|
@@ -3213,10 +3233,11 @@
    PCL::|(FAST-READER-METHOD SLOT-OBJECT NKEYS)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
-   S::C-SET-STREAM-OBJECT0 PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
-   S::C-FUNCTION-NEVAL PCL::EQL-SPECIALIZER-SIMPLE-TYPEP-FN
-   PCL::ONE-INDEX-INDEX PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|
-   PCL::SLOTS-TO-REVERT PCL::NUMBER-REQUIRED
+   CSTRUCT::C-SET-STREAM-OBJECT0
+   PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION CSTRUCT::C-FUNCTION-NEVAL
+   PCL::EQL-SPECIALIZER-SIMPLE-TYPEP-FN PCL::ONE-INDEX-INDEX
+   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY| PCL::SLOTS-TO-REVERT
+   PCL::NUMBER-REQUIRED
    PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION FUNCTION)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
    PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
@@ -3269,19 +3290,19 @@
    PCL::FSC-INSTANCE-WRAPPER PCL::EARLY-GF-NAME PCL::ALLOCATE-FUNCTION
    PCL::TABLE-ENTRY PCL::OLD COMMON-LISP::UPGRADED-COMPLEX-PART-TYPE
    PCL::CHECKING-DFUN-INFO PCL::COND-CLAUSES PCL::FROM-LINE
-   PCL::LINE-SEPARATION COMMON-LISP::PHASE S::C-CONS-CAR PCL::HIT
+   PCL::LINE-SEPARATION COMMON-LISP::PHASE CSTRUCT::C-CONS-CAR PCL::HIT
    PCL::*KEYWORD-PACKAGE*
    PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
    PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
    PCL::WHY PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
-   S::ADJUSTABLE-VECTOR COMMON-LISP::NBUTLAST
+   CSTRUCT::ADJUSTABLE-VECTOR COMMON-LISP::NBUTLAST
    PCL::CALL-NEXT-METHOD-BIND PCL::SLOT-INSTANCE
    PCL::|SYSTEM::S-DATA class predicate| PCL::CHECK-DOCUMENTATION
    COMMON-LISP::BIT PCL::DIRECT-SUPERCLASSES-P PCL::CONC-NAME
    PCL::SUPER-SLOTS PCL::NEXT-LINE COMMON-LISP::READ-LINE
    PCL::RECOMP-REASONS PCL::SLOT-NAME PCL::SLOT-NAMES
    PCL::FIND-SUPERCLASS-CHAIN PCL::CHASE PCL::FAST-METHOD-CALL-FUNCTION
-   PCL::|ARG-INFO SLOT8| S::C-SET-HASHTABLE-NENT PCL::PV-OFFSET
+   PCL::|ARG-INFO SLOT8| CSTRUCT::C-SET-HASHTABLE-NENT PCL::PV-OFFSET
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
    COMMON-LISP::HASH-TABLE-COUNT COMMON-LISP::CHAR-NAME
    PCL::|(FAST-READER-METHOD SLOT-OBJECT LENGTH)| PCL::EVAL-FORM
@@ -3302,7 +3323,7 @@
    COMMON-LISP::CHAR-EQUAL PCL::READ-FORM PCL::WRAPPER-OF-MACRO
    COMMON-LISP::FILE-ERROR PCL::CPL-INCONSISTENT-ERROR PCL::ALL-KEYS
    PCL::|ARG-INFO SLOT7| COMMON-LISP::SUBSTITUTE WALKER::WALK-FORM
-   S::C-SET-T-PD1 COMMON-LISP::LOGEQV COMMON-LISP::CELL-ERROR
+   CSTRUCT::C-SET-T-PD1 COMMON-LISP::LOGEQV COMMON-LISP::CELL-ERROR
    PCL::CACHE-VALUEP PCL::CONVERT-METHODS PCL::MAKE-CONSTANT-VALUE
    COMMON-LISP::ARRAY-ROW-MAJOR-INDEX
    PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE PCL::DIFF PCL::REQ-ARGS
@@ -3327,37 +3348,37 @@
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::NAME)|
    COMMON-LISP::MERGE COMMON-LISP::CHAR> PCL::STRING-LOC
-   S::C-ARRAY-ELTTYPE PCL::UNTRACE-METHOD PCL::BEEN-HERE
+   CSTRUCT::C-ARRAY-ELTTYPE PCL::UNTRACE-METHOD PCL::BEEN-HERE
    PCL::MAIN-EFFECTIVE-METHOD COMMON-LISP::CHAR= PCL::AUGMENT-TYPE
-   PCL::NEXT PCL::PORT-DEVICE S::C-T-EMF PCL::SDFUN-FOR-CACHING
+   PCL::NEXT PCL::PORT-DEVICE CSTRUCT::C-T-EMF PCL::SDFUN-FOR-CACHING
    COMMON-LISP::NSTRING-CAPITALIZE PCL::*INVALID-METHOD-ERROR*
    COMMON-LISP::CHAR< PCL::COLLECT
    PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE
    COMMON-LISP::PPRINT-DISPATCH PCL::UNDEFMETHOD PCL::IN-THE-COMPILER-P
    COMMON-LISP::QUOTE COMMON-LISP::MULTIPLE-VALUE-SETQ
    PCL::CLASS-DEFSTRUCT-FORM PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST
-   PCL::|ARG-INFO SLOT5| S::C-SET-T-MELTSIZE PCL::NO-CLASS-SLOTS-P
-   PCL::INCLUDED-NAME PCL::SUPER PCL::MAKE-ONE-INDEX-DFUN-INFO
-   COMMON-LISP::READ-BYTE PCL::SPECIALIZED-POSITIONS
-   PCL::SPECIALIZED-ARGUMENT-POSITIONS COMMON-LISP::COMPILE-FILE
-   PCL::PSYMS PCL::ARGLIST PCL::MAKE-METHOD-INITARGS-FORM
-   COMMON-LISP::REQUIRE
+   PCL::|ARG-INFO SLOT5| CSTRUCT::C-SET-T-MELTSIZE
+   PCL::NO-CLASS-SLOTS-P PCL::INCLUDED-NAME PCL::SUPER
+   PCL::MAKE-ONE-INDEX-DFUN-INFO COMMON-LISP::READ-BYTE
+   PCL::SPECIALIZED-POSITIONS PCL::SPECIALIZED-ARGUMENT-POSITIONS
+   COMMON-LISP::COMPILE-FILE PCL::PSYMS PCL::ARGLIST
+   PCL::MAKE-METHOD-INITARGS-FORM COMMON-LISP::REQUIRE
    PCL::|(FAST-READER-METHOD SLOT-OBJECT LIMIT-FN)|
    COMMON-LISP::MEMBER-IF PCL::CLASS-EQ-TYPE PCL::CHECK-METHOD-ARG-INFO
    PCL::*CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P* PCL::DIR
-   S::C-PACKAGE-INTERNAL_SIZE PCL::OINDEX PCL::WFT-TYPE2
+   CSTRUCT::C-PACKAGE-INTERNAL_SIZE PCL::OINDEX PCL::WFT-TYPE2
    PCL::COMPILE-MODULE COMMON-LISP::UNSIGNED-BYTE PCL::DEFINITE-P
    COMMON-LISP::ASSERT PCL::PKG PCL::METHOD-ALLOW-OTHER-KEYS
-   S::C-SET-T-MWRITABLE PCL::WRITERS PCL::EXPAND-DEFGENERIC
-   S::C-SET-ARRAY-DIM PCL::|ARG-INFO SLOT4| PCL::TEST-FUNCTION
+   CSTRUCT::C-SET-T-MWRITABLE PCL::WRITERS PCL::EXPAND-DEFGENERIC
+   CSTRUCT::C-SET-ARRAY-DIM PCL::|ARG-INFO SLOT4| PCL::TEST-FUNCTION
    PCL::*EMIT-FUNCTION-P* COMMON-LISP::VECTOR SYSTEM::CLINES
-   PCL::NEXT-METHODS COMMON-LISP::TENTH PCL::CNM-METHODS S::C-T-FW
-   PCL::CACHED-NEW-KEYS PCL::|COMPILER::FN SLOT8| PCL::CHECKING-CACHE
-   COMMON-LISP::LISTEN PCL::CONTENDERS
+   PCL::NEXT-METHODS COMMON-LISP::TENTH PCL::CNM-METHODS
+   CSTRUCT::C-T-FW PCL::CACHED-NEW-KEYS PCL::|COMPILER::FN SLOT8|
+   PCL::CHECKING-CACHE COMMON-LISP::LISTEN PCL::CONTENDERS
    COMMON-LISP::MULTIPLE-VALUES-LIMIT
    PCL::|STRUCTURE-OBJECT class constructor| PCL::ORDER-CLEANUPS
    PCL::GENERATOR-ENTRY COMMON-LISP::BIGNUM COMMON-LISP::LIST-LENGTH
-   PCL::SET-P S::C-SET-FUNCTION-MAXARG PCL::MAKE-SPECIALIZABLE
+   PCL::SET-P CSTRUCT::C-SET-FUNCTION-MAXARG PCL::MAKE-SPECIALIZABLE
    PCL::ARGUMENT PCL::DIRECT COMMON-LISP::WRITE-TO-STRING
    PCL::|ARG-INFO SLOT3| PCL::NINDEX COMMON-LISP::FROUND PCL::DUMMY
    PCL::NICK COMMON-LISP::PRIN1-TO-STRING COMMON-LISP::PRINC-TO-STRING
@@ -3368,10 +3389,10 @@
    PCL::EARLY-METHOD-QUALIFIERS COMMON-LISP::*LOAD-PATHNAME*
    PCL::CACHED-CONSTANTS PCL::SETF-VAR PCL::MODIFY-CACHE
    PCL::PV-OFFSET-FORM PCL::MAKE-DEFAULT-INITARGS-FORM-LIST
-   COMMON-LISP::REMOVE-IF-NOT S::C-SET-ADJVECTOR-FILLP PCL::INDEX-FORM
-   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR PCL::GCL_PCL_LOW
-   COMMON-LISP::PARSE-ERROR PCL::%INSTANCE-REF ITERATE::LIST-ELEMENTS
-   PCL::|ARG-INFO SLOT2| PCL::GET-KEY-ARG-TAIL
+   COMMON-LISP::REMOVE-IF-NOT CSTRUCT::C-SET-ADJVECTOR-FILLP
+   PCL::INDEX-FORM PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR
+   PCL::GCL_PCL_LOW COMMON-LISP::PARSE-ERROR PCL::%INSTANCE-REF
+   ITERATE::LIST-ELEMENTS PCL::|ARG-INFO SLOT2| PCL::GET-KEY-ARG-TAIL
    COMMON-LISP::DOUBLE-FLOAT-EPSILON
    COMMON-LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON PCL::READER-NAMES
    PCL::CHECK-SPECIALIZERS PCL::INITIALIZE-INFO
@@ -3379,33 +3400,35 @@
    COMMON-LISP::STRING-NOT-LESSP PCL::FIN-LAMBDA-FN
    PCL::MAKE-DEFMETHOD-FORM COMMON-LISP::PACKAGE-ERROR
    PCL::EMIT-FETCH-WRAPPER PCL::INTERN-PV-TABLE PCL::ALL-CPDS
-   COMMON-LISP::DELETE-IF-NOT PCL::SPECIALIZER-CACHE S::STRCAT
+   COMMON-LISP::DELETE-IF-NOT PCL::SPECIALIZER-CACHE CSTRUCT::STRCAT
    PCL::CNM-ARGS PCL::PV-TABLE-CACHE COMMON-LISP::MEMBER-IF-NOT
    PCL::|COMPILER::FN SLOT6| PCL::VALUE-FOR-CACHING PCL::ADD-TO-CVECTOR
    PCL::UNTRACE-1 PCL::MAKE-METHOD-FUNCTION-INTERNAL
    PCL::MAKE-METHOD-LAMBDA-INTERNAL
    PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL COMMON-LISP::LONG-FLOAT
-   COMMON-LISP::SIMPLE-VECTOR-P S::C-STREAM-MODE PCL::DFUN-INFO-CACHE
-   COMMON-LISP::ECHO-STREAM-INPUT-STREAM
-   COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM S::C-SET-FUNCTION-MINARG
-   COMMON-LISP::ARRAY-RANK COMMON-LISP::LAMBDA-PARAMETERS-LIMIT
-   PCL::FIRST-FORM-TO-LISP PCL::NOT-IN-CACHE PCL::DEFSTRUCT-FORM
-   PCL::|ARG-INFO SLOT1| PCL::GF-DFUN-CACHE PCL::SPECL+SLOTD-LIST
-   PCL::GF-ARG-INFO S::C-STREAM-FD S::C-FLOAT-FIXNUM-==
+   COMMON-LISP::SIMPLE-VECTOR-P CSTRUCT::C-STREAM-MODE
+   PCL::DFUN-INFO-CACHE COMMON-LISP::ECHO-STREAM-INPUT-STREAM
+   COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM
+   CSTRUCT::C-SET-FUNCTION-MINARG COMMON-LISP::ARRAY-RANK
+   COMMON-LISP::LAMBDA-PARAMETERS-LIMIT PCL::FIRST-FORM-TO-LISP
+   PCL::NOT-IN-CACHE PCL::DEFSTRUCT-FORM PCL::|ARG-INFO SLOT1|
+   PCL::GF-DFUN-CACHE PCL::SPECL+SLOTD-LIST PCL::GF-ARG-INFO
+   CSTRUCT::C-STREAM-FD CSTRUCT::C-FLOAT-FIXNUM-==
    PCL::LAMBDA-EXPRESSION PCL::SHORT-METHOD-COMBINATION-P
    PCL::GCL_PCL_ENV COMMON-LISP::DEFVAR PCL::WRAPPER-EQ
    PCL::LINE-FULL-P PCL::|COMPILER::FN SLOT5| PCL::FUNCALLABLE
-   PCL::NO-OF-SLOTS COMMON-LISP::DEFSTRUCT S::C-PACKAGE-EXTERNAL_SIZE
-   PCL::.FUNCTION. PCL::CFUNCTION PCL::TFUNCTION PCL::OFUNCTION
-   PCL::DEFAULT-INITARGS-1 COMMON-LISP::DEFINE-COMPILER-MACRO
-   PCL::ARG-INFO PCL::|ARG-INFO SLOT0| PCL::FAST-METHOD-CALL-P
+   PCL::NO-OF-SLOTS COMMON-LISP::DEFSTRUCT
+   CSTRUCT::C-PACKAGE-EXTERNAL_SIZE PCL::.FUNCTION. PCL::CFUNCTION
+   PCL::TFUNCTION PCL::OFUNCTION PCL::DEFAULT-INITARGS-1
+   COMMON-LISP::DEFINE-COMPILER-MACRO PCL::ARG-INFO
+   PCL::|ARG-INFO SLOT0| PCL::FAST-METHOD-CALL-P
    PCL::|(WRITER OPTIONS)| PCL::|(WRITER METHODS)| COMMON-LISP::BOOLEAN
-   S::C-SET-ADJARRAY-DISPLACED COMMON-LISP::SUBTYPEP
-   PCL::%CHECK-CNM-ARGS S::C-CHARACTER-CODE
+   CSTRUCT::C-SET-ADJARRAY-DISPLACED COMMON-LISP::SUBTYPEP
+   PCL::%CHECK-CNM-ARGS CSTRUCT::C-CHARACTER-CODE
    PCL::STD-CLASS-SIMPLE-TYPEP-FN PCL::READER-SYMBOL
-   S::C-SET-T-MHASFILLP PCL::|COMPILER::FN SLOT4| S::*DOUBLE
-   COMMON-LISP::EVERY PCL::METHOD-LAMBDA-ARGS
-   PCL::ONE-INDEX-DFUN-INFO-INDEX S::C-FLOAT-FIXNUM->
+   CSTRUCT::C-SET-T-MHASFILLP PCL::|COMPILER::FN SLOT4|
+   CSTRUCT::*DOUBLE COMMON-LISP::EVERY PCL::METHOD-LAMBDA-ARGS
+   PCL::ONE-INDEX-DFUN-INFO-INDEX CSTRUCT::C-FLOAT-FIXNUM->
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
    PCL::INSTANCE-SLOTS PCL::OBJECTSP PCL::DFUN-INFO PCL::DFUN-INFO-
    PCL::FILENAMES PCL::SETF-CASE
@@ -3418,7 +3441,7 @@
    COMMON-LISP::COPY-STRUCTURE PCL::|COMPILER::FN SLOT3| PCL::PV-W-T
    PCL::MAP-SPECIALIZERS COMMON-LISP::SYNONYM-STREAM-SYMBOL
    COMMON-LISP::REMOVE-DUPLICATES PCL::.CONSTANT.
-   PCL::INSTANCE-SLOT-INDEX S::C-SET-T-MELTMODE
+   PCL::INSTANCE-SLOT-INDEX CSTRUCT::C-SET-T-MELTMODE
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::FROZEN)|
    PCL::WALK-FUNCTION COMMON-LISP::SUBLIS PCL::STD-METHOD
    PCL::STR-METHOD
@@ -3432,7 +3455,7 @@
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CALL-METHOD-ARGS)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::MACROS)|
    PCL::|(WRITER DIRECT-METHODS)| PCL::|(WRITER DIRECT-SLOTS)|
-   PCL::NREQUIRED PCL::NREQUIREDS S::C-SET-HASHTABLE-RHTHRESH
+   PCL::NREQUIRED PCL::NREQUIREDS CSTRUCT::C-SET-HASHTABLE-RHTHRESH
    PCL::ACCESSOR-VALUES1 PCL::SORTED-P COMMON-LISP::FUNCTION
    COMMON-LISP::FUNCTIONP
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OVERFLOW)| PCL::OLD-METHOD
@@ -3451,7 +3474,7 @@
    PCL::IGNORE2 PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NLINES)|
    PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| PCL::|__si::MAKE-DFUN-INFO|
    PCL::|__si::MAKE-ARG-INFO| PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|
-   PCL::METHOD-CALL COMMON-LISP::/// S::C-SET-PATHNAME-VERSION
+   PCL::METHOD-CALL COMMON-LISP::/// CSTRUCT::C-SET-PATHNAME-VERSION
    PCL::CPD-COUNT PCL::MODULE-P PCL::MAKE-INITIALIZE-INFO
    COMMON-LISP::APPEND PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OWNER)|
    PCL::OLD-COUNT PCL::WRAPPER-1 PCL::RWALK COMMON-LISP::SIN
@@ -3464,7 +3487,7 @@
    PCL::MAKE-UNORDERED-METHODS-EMF PCL::WITH-LOCAL-CACHE-FUNCTIONS
    PCL::|COMPILER::FN SLOT1| PCL::METHOD-ALIST-P
    COMMON-LISP::NAMESTRING PCL::FIN PCL::PROTO-GF
-   PCL::DEFINE-GF-PREDICATE S::C-FLOAT-DOUBLE-==
+   PCL::DEFINE-GF-PREDICATE CSTRUCT::C-FLOAT-DOUBLE-==
    PCL::|PCL::PLIST-MIXIN class predicate| PCL::AROUND
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
    PCL::|(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
@@ -3493,7 +3516,7 @@
    PCL::INITIAL-VALUE COMMON-LISP::SINGLE-FLOAT-EPSILON
    COMMON-LISP::SINGLE-FLOAT-NEGATIVE-EPSILON PCL::OLD-INTERN-P
    PCL::|(BOUNDP PLIST)| ITERATE::ELEMENTS PCL::READER PCL::ACC-NAME
-   PCL::MEC-ALL-CLASSES S::C-SET-FUNCTION-DATA
+   PCL::MEC-ALL-CLASSES CSTRUCT::C-SET-FUNCTION-DATA
    PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::SLOT-ACCESSOR-FUNCTION
    PCL::WRAPPER-CLASS PCL::RENAME-PCL PCL::.SLOTS. PCL::ECD-METACLASS
    PCL::REAL-GET-METHOD PCL::GCL_PCL_INIT PCL::FIND-FREE
@@ -3506,7 +3529,7 @@
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
    COMMON-LISP::MAPCON PCL::NET-CODE-CONVERTER COMMON-LISP::FILE-STREAM
    PCL::|(WRITER CAN-PRECEDE-LIST)| PCL::METH PCL::|(READER OPTIONS)|
-   PCL::|(READER METHODS)| S::*UINT PCL::DIRECT-DEFAULT-INITARGS
+   PCL::|(READER METHODS)| CSTRUCT::*UINT PCL::DIRECT-DEFAULT-INITARGS
    PCL::GCL_PCL_MACROS PCL::BINDING COMMON-LISP::CONSTANTP
    COMMON-LISP::NIL PCL::|(WRITER SLOT-DEFINITION)|
    PCL::|COMPILER::BINDING SLOT1|
@@ -3515,7 +3538,7 @@
    PCL::GCL_PCL_FIXUP PCL::|(BOUNDP CLASS)| PCL::CURRENT
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD)| PCL::EXCL
    COMMON-LISP::WRITE-STRING PCL::FUNCALLABLE-STANDARD-CLASS-P
-   S::C-ADJARRAY-DISPLACED COMMON-LISP::MAKE-STRING-INPUT-STREAM
+   CSTRUCT::C-ADJARRAY-DISPLACED COMMON-LISP::MAKE-STRING-INPUT-STREAM
    COMMON-LISP::MAKE-STRING-OUTPUT-STREAM PCL::GCL_PCL_COMPAT PCL::ZERO
    PCL::.VALID-KEYS. COMMON-LISP::COPY-ALIST
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::DEF)|
@@ -3551,7 +3574,7 @@
    PCL::STANDARD-WRITER-METHOD-SIMPLE-TYPEP-FN
    PCL::BOOTSTRAP-SLOT-INDEX PCL::NOT-SIMPLE-P-CELL
    PCL::GF-INFO-FAST-MF-P PCL::EARLY-CLASS-DEFINITION
-   PCL::METHOD-COMBINATION-OPTIONS S::C-OCOMPLEX-IMAG
+   PCL::METHOD-COMBINATION-OPTIONS CSTRUCT::C-OCOMPLEX-IMAG
    PCL::|(READER METHOD-COMBINATION)|
    PCL::|(READER INTERNAL-READER-FUNCTION)|
    PCL::|(READER INTERNAL-WRITER-FUNCTION)| PCL::|(SETF OBJECT-PLIST)|
@@ -3560,8 +3583,8 @@
    COMMON-LISP::DELETE-PACKAGE PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
    PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES COMMON-LISP::LOGORC2
    PCL::COLLECTED PCL::CAN-PRECEDE-LIST PCL::NLOCAL
-   COMMON-LISP::RENAME-PACKAGE S::C-SET-T-MADJUSTABLE PCL::CACHED-EMF-P
-   PCL::REAL-BODY COMMON-LISP::*PRINT-RIGHT-MARGIN*
+   COMMON-LISP::RENAME-PACKAGE CSTRUCT::C-SET-T-MADJUSTABLE
+   PCL::CACHED-EMF-P PCL::REAL-BODY COMMON-LISP::*PRINT-RIGHT-MARGIN*
    PCL::TWO-CLASS-INDEX COMMON-LISP::EXP COMMON-LISP::MAPCAN
    PCL::CALL-INITIALIZE-INSTANCE-SIMPLE PCL::|(READER FAST-FUNCTION)|
    PCL::|(WRITER ALLOCATION)| PCL::|__si::MAKE-CONSTANT-VALUE|
@@ -3576,7 +3599,7 @@
    PCL::|(WRITER SLOT-NAME)| PCL::DESC COMMON-LISP::ASSOC
    PCL::MAP-ALL-CLASSES PCL::STANDARD-CLASS-WRAPPER
    PCL::CAR-ALL-CLASSES PCL::OPTIMIZE-INSTANCE-ACCESS
-   PCL::CACHED-INDEX-P PCL::FAST-METHOD PCL::.EMF. S::DEFDLFUN
+   PCL::CACHED-INDEX-P PCL::FAST-METHOD PCL::.EMF. CSTRUCT::DEFDLFUN
    PCL::FIELD-TYPE-SIMPLE-TYPEP-FN COMMON-LISP::DO*
    COMMON-LISP::PATHNAME-VERSION COMMON-LISP::NSUBSTITUTE-IF-NOT
    PCL::MAIN-METHOD PCL::SAUT-CLASS-EQ PCL::GCL_PCL_COMBIN
@@ -3597,7 +3620,7 @@
    PCL::|(WRITER INITFORM)| COMMON-LISP::LOGCOUNT PCL::TYPE-CLASS
    PCL::|__si::MAKE-PV-TABLE| PCL::*REBOUND-EFFECTIVE-METHOD-GENSYMS*
    PCL::SLOT-ACCESSOR-STD-P PCL::DESTRUCTURE-INTERNAL
-   PCL::|(WRITER WRITERS)| S::MATRIX PCL::OBSOLETE-INSTANCE-TRAP
+   PCL::|(WRITER WRITERS)| CSTRUCT::MATRIX PCL::OBSOLETE-INSTANCE-TRAP
    COMMON-LISP::FUNCALL PCL::INITARG PCL::SLOT-CLASS
    COMMON-LISP::DECLAIM PCL::FAST-READER-METHOD
    PCL::|(WRITER INITFUNCTION)| PCL::|(WRITER WRITER-FUNCTION)|
@@ -3628,15 +3651,15 @@
    PCL::SWAP-WRAPPERS-AND-SLOTS PCL::OPTIMIZE-WRITER
    PCL::|PCL::CLASS-PRECEDENCE-DESCRIPTION class predicate|
    PCL::|PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate|
-   S::C-RATIO-NUM PCL::STANDARD-DIRECT-SLOT-DEFINITION-WRAPPER
+   CSTRUCT::C-RATIO-NUM PCL::STANDARD-DIRECT-SLOT-DEFINITION-WRAPPER
    PCL::|(READER SLOT-DEFINITION)| COMMON-LISP::ECHO-STREAM
    PCL::LINE-PRIMARY-LOCATION PCL::FOR-CACHE-P PCL::ADDED-SLOTS
    PCL::EARLY-COLLECT-SLOTS COMMON-LISP::NTHCDR
-   PCL::INTERNAL-WRITER-FUNCTION S::C-SET-PACKAGE-SHADOWINGS
+   PCL::INTERNAL-WRITER-FUNCTION CSTRUCT::C-SET-PACKAGE-SHADOWINGS
    PCL::PARSE-METHOD-OR-SPEC PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL
    PCL::REASON PCL::CVECTOR-TYPE PCL::FINALLY PCL::GCL_PCL_PKG
    PCL::|(READER LAMBDA-LIST)| COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
-   PCL::|__si::MAKE-STD-INSTANCE| S::*UCHAR PCL::GENS PCL::OFFSET
+   PCL::|__si::MAKE-STD-INSTANCE| CSTRUCT::*UCHAR PCL::GENS PCL::OFFSET
    PCL::SPECL2 PCL::STANDARD-CLASS-SIMPLE-TYPEP-FN
    PCL::STANDARD-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::NEW-INTERN-P
    COMMON-LISP::WITH-STANDARD-IO-SYNTAX PCL::VAXL-LOW
@@ -3658,7 +3681,7 @@
    PCL::SLOT-NAME-LISTS-FROM-SLOTS PCL::LEGAL PCL::.ARG2.
    PCL::|(WRITER IDENTITY-WITH-ONE-ARGUMENT)|
    COMMON-LISP::DESTRUCTURING-BIND COMMON-LISP::ACOSH
-   S::C-SET-PACKAGE-NICKNAMES PCL::OPTIMIZE-SLOT-BOUNDP
+   CSTRUCT::C-SET-PACKAGE-NICKNAMES PCL::OPTIMIZE-SLOT-BOUNDP
    PCL::|(CALL REAL-ENSURE-GF-USING-CLASS--NULL)| PCL::GCL_PCL_FSC
    PCL::GET-MAKE-INSTANCE-FUNCTIONS PCL::CANONICALIZE-DEFCLASS-OPTION
    PCL::CANONICALIZE-SLOT-SPECIFICATION
@@ -3668,8 +3691,8 @@
    PCL::CHECK-DECLARATION PCL::INITIALIZE-INFO-CACHED-NEW-KEYS
    PCL::INITIALIZE-INFO-NEW-KEYS PCL::REAL-ADD-METHOD PCL::.ARG0.
    COMMON-LISP::SUBSETP COMMON-LISP::NUMBERP COMMON-LISP::RESTART-NAME
-   PCL::REDIRECT-EARLY-FUNCTION-INTERNAL S::C-SET-SYMBOL-PLIST
-   S::C-RATIO-DEN PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION-WRAPPER
+   PCL::REDIRECT-EARLY-FUNCTION-INTERNAL CSTRUCT::C-SET-SYMBOL-PLIST
+   CSTRUCT::C-RATIO-DEN PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION-WRAPPER
    PCL::|(READER ALLOCATION)| COMMON-LISP::SUBST PCL::DEFAULT-METHOD
    SYSTEM::MEMQ COMMON-LISP::DOTIMES PCL::TEMP PCL::UNORDERED-METHODS
    PCL::SLOT-OBJECT COMMON-LISP::BOOLE-C1
@@ -3678,10 +3701,10 @@
    SYSTEM::C-FLOAT-== PCL::METHOD-FUNCTION-RETURNING-NIL
    PCL::DESIRABILITY PCL::|PCL::TWO-CLASS class predicate|
    PCL::PARSE-KEYWORD-ARGUMENT
-   PCL::|(WRITER INCOMPATIBLE-SUPERCLASS-LIST)| S::C-STREAM-OBJECT1
-   PCL::|(READER INITIAL-METHODS)| PCL::DESCEND
-   PCL::STANDARD-DIRECT-SLOT-DEFINITION-SIMPLE-TYPEP-FN
-   PCL::|(READER SLOT-NAME)| COMMON-LISP::LET* S::C-T-MOFFSET
+   PCL::|(WRITER INCOMPATIBLE-SUPERCLASS-LIST)|
+   CSTRUCT::C-STREAM-OBJECT1 PCL::|(READER INITIAL-METHODS)|
+   PCL::DESCEND PCL::STANDARD-DIRECT-SLOT-DEFINITION-SIMPLE-TYPEP-FN
+   PCL::|(READER SLOT-NAME)| COMMON-LISP::LET* CSTRUCT::C-T-MOFFSET
    PCL::CANONICAL-SLOTS PCL::*RAISE-METATYPES-TO-CLASS-P*
    PCL::TWO-CLASS-WRAPPER1 PCL::LINE-WRAPPERS PCL::GET-FUNCTION1
    PCL::STANDARD-GENERIC-FUNCTION-WRAPPER PCL::.PLIST-TAIL.
@@ -3695,25 +3718,26 @@
    PCL::GENERATE-DISCRIMINATION-NET-INTERNAL PCL::STRINGS
    COMMON-LISP::SUBST-IF-NOT COMMON-LISP::STRING
    COMMON-LISP::*PRINT-GENSYM* PCL::REL-8 PCL::NEW-POSITION
-   S::C-STREAM-OBJECT0 PCL::CACHE-LINE-SIZE PCL::NAME-DSLOTDS-ALIST
-   PCL::DECLS PCL::GET-DECLARATION PCL::WALKED-LAMBDA
-   PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD PCL::STANDARD-BOUNDP-METHOD
-   PCL::STANDARD-METHOD-COMBINATION PCL::FEATURE COMMON-LISP::NCONC
-   S::C-BIGNUM-MPZ_T PCL::|FAST-METHOD-CALL SLOT3|
-   PCL::EXPANDING-MAKE-INSTANCE PCL::GET-SECONDARY-DISPATCH-FUNCTION
-   PCL::TWO-CLASS-WRAPPER0 PCL::INSTANCE-READ PCL::SAUT-NOT
-   PCL::|(WRITER DOCUMENTATION)| PCL::|(WRITER LOCATION)|
-   COMMON-LISP::COMPILATION-SPEED PCL::METHOD-COMBINATION-P
-   PCL::OWRAPPER PCL::NWRAPPER PCL::CWRAPPER PCL::LWRAPPER
-   PCL::|(READER INITFORM)| PCL::UNPARSE-SPECIALIZERS PCL::TI-LOW
-   PCL::|(WRITER ACCESSOR-FLAGS)| PCL::.NEXT-METHOD-CALL. PCL::FROM-LOC
-   PCL::PPSYMS PCL::*NEXT-METHODS* COMMON-LISP::MAKE-ECHO-STREAM
-   PCL::|(READER WRITERS)| PCL::|(WRITER CLASS-PRECEDENCE-LIST)|
-   PCL::OTHER-INITARGS PCL::DELQ PCL::EARLY-CLASS-NAME
-   COMMON-LISP::NUMBER PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P
-   COMMON-LISP::ERROR PCL::TWO-CLASS-ACCESSOR-TYPE PCL::.METHOD.
-   PCL::GF-VAR PCL::INITIALIZE-INFO-CACHED-CONSTANTS
-   PCL::INITIALIZE-INFO-CONSTANTS PCL::|FAST-METHOD-CALL SLOT2|
+   CSTRUCT::C-STREAM-OBJECT0 PCL::CACHE-LINE-SIZE
+   PCL::NAME-DSLOTDS-ALIST PCL::DECLS PCL::GET-DECLARATION
+   PCL::WALKED-LAMBDA PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
+   PCL::STANDARD-BOUNDP-METHOD PCL::STANDARD-METHOD-COMBINATION
+   PCL::FEATURE COMMON-LISP::NCONC CSTRUCT::C-BIGNUM-MPZ_T
+   PCL::|FAST-METHOD-CALL SLOT3| PCL::EXPANDING-MAKE-INSTANCE
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION PCL::TWO-CLASS-WRAPPER0
+   PCL::INSTANCE-READ PCL::SAUT-NOT PCL::|(WRITER DOCUMENTATION)|
+   PCL::|(WRITER LOCATION)| COMMON-LISP::COMPILATION-SPEED
+   PCL::METHOD-COMBINATION-P PCL::OWRAPPER PCL::NWRAPPER PCL::CWRAPPER
+   PCL::LWRAPPER PCL::|(READER INITFORM)| PCL::UNPARSE-SPECIALIZERS
+   PCL::TI-LOW PCL::|(WRITER ACCESSOR-FLAGS)| PCL::.NEXT-METHOD-CALL.
+   PCL::FROM-LOC PCL::PPSYMS PCL::*NEXT-METHODS*
+   COMMON-LISP::MAKE-ECHO-STREAM PCL::|(READER WRITERS)|
+   PCL::|(WRITER CLASS-PRECEDENCE-LIST)| PCL::OTHER-INITARGS PCL::DELQ
+   PCL::EARLY-CLASS-NAME COMMON-LISP::NUMBER
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P COMMON-LISP::ERROR
+   PCL::TWO-CLASS-ACCESSOR-TYPE PCL::.METHOD. PCL::GF-VAR
+   PCL::INITIALIZE-INFO-CACHED-CONSTANTS PCL::INITIALIZE-INFO-CONSTANTS
+   PCL::|FAST-METHOD-CALL SLOT2|
    PCL::INITIALIZE-INTERNAL-SLOT-FUNCTIONS COMMON-LISP::MAKE-STRING
    COMMON-LISP::BASE-STRING COMMON-LISP::RESTART-BIND
    PCL::METHOD-FUNCTION-PV-TABLE PCL::SV PCL::|(READER INITFUNCTION)|
@@ -3730,7 +3754,7 @@
    COMMON-LISP::*RANDOM-STATE*
    PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN
    PCL::|(WRITER PREDICATE-NAME)| WALKER::VARIABLE-SPECIAL-P
-   S::C-SET-OCOMPLEX-IMAG PCL::DONT-CREATE-P
+   CSTRUCT::C-SET-OCOMPLEX-IMAG PCL::DONT-CREATE-P
    PCL::|FAST-METHOD-CALL SLOT1|
    PCL::|(SETF CLASS-DEFSTRUCT-CONSTRUCTOR)| COMMON-LISP::NULL
    PCL::METHOD-COMBINATION-SUPPLIED-P COMMON-LISP::CHAR-GREATERP
@@ -3742,8 +3766,9 @@
    PCL::CELL PCL::BUILT-IN-INSTANCE PCL::MAKE-PV-TYPE-DECLARATION
    PCL::DFUN-WRAPPERS PCL::UPDATE-C-A-M-GF-INFO COMMON-LISP::MEMBER
    PCL::UPDATE-ALL-PV-TABLE-CACHES PCL::GF-LIST PCL::OTHER
-   S::C-SET-PACKAGE-INTERNAL_SIZE S::C-SET-PACKAGE-EXTERNAL_SIZE
-   PCL::ONE-CLASS-INDEX PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
+   CSTRUCT::C-SET-PACKAGE-INTERNAL_SIZE
+   CSTRUCT::C-SET-PACKAGE-EXTERNAL_SIZE PCL::ONE-CLASS-INDEX
+   PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
    PCL::STANDARD-METHOD-SIMPLE-TYPEP-FN
    PCL::STANDARD-READER-METHOD-SIMPLE-TYPEP-FN
    PCL::STANDARD-GENERIC-FUNCTION-SIMPLE-TYPEP-FN
@@ -3785,10 +3810,10 @@
    COMMON-LISP::*PRINT-CASE* COMMON-LISP::OPTIMIZE
    PCL::|COMPILER::FN class predicate| PCL::MAX-LOCATION PCL::PROTO
    PCL::UPDATE-FN PCL::%INVALID-QUALIFIERS PCL::FLUSH-CACHE-TRAP
-   S::+FL+ PCL::UPDATE-ALL-C-A-M-GF-INFO COMMON-LISP::ABORT
+   CSTRUCT::+FL+ PCL::UPDATE-ALL-C-A-M-GF-INFO COMMON-LISP::ABORT
    PCL::|(READER INCOMPATIBLE-SUPERCLASS-LIST)|
    PCL::STANDARD-OBJECT-SIMPLE-TYPEP-FN COMMON-LISP::PATHNAME-MATCH-P
-   WALKER::VARIABLE-GLOBALLY-SPECIAL-P S::C-SET-HASHTABLE-PAD5
+   WALKER::VARIABLE-GLOBALLY-SPECIAL-P CSTRUCT::C-SET-HASHTABLE-PAD5
    PCL::MAKE-WRITER-METHOD-FUNCTION
    PCL::CLASS-PROTOTYPE-SPECIALIZER-SIMPLE-TYPEP-FN PCL::SLOT-VAR
    PCL::MAKE-BUILT-IN-WRAPPER-OF-BODY PCL::CHOICES
@@ -3797,9 +3822,9 @@
    PCL::*BUILT-IN-TYPEP-COST* PCL::DESTRUCTURE
    PCL::TRY-ONE-FILL-FROM-LINE PCL::SLOT+INDEX
    COMMON-LISP::GET-DECODED-TIME PCL::SUPERCLASS-NAMES
-   PCL::LOAD-TRUENAME S::*OBJECT PCL::|(SETF CLASS-SLOT-VALUE)|
-   COMMON-LISP::ATOM PCL::.GF-ARGS. S::C-SET-HASHTABLE-PAD4 PCL::READP
-   PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::LOAD-TRUENAME CSTRUCT::*OBJECT PCL::|(SETF CLASS-SLOT-VALUE)|
+   COMMON-LISP::ATOM PCL::.GF-ARGS. CSTRUCT::C-SET-HASHTABLE-PAD4
+   PCL::READP PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
    PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION-SYMBOL
    COMMON-LISP::CDADDR PCL::CLASS-INITIALIZE-INFO PCL::AUX
    PCL::.CM-ARGS. PCL::OLD-CLASS-SLOTS PCL::|(READER DOCUMENTATION)|
@@ -3811,26 +3836,26 @@
    PCL::RASSQ PCL::LOCATION-WRAPPERS PCL::DLAP-LAMBDA-LIST
    COMMON-LISP::CDADAR PCL::FUNCTION-SPECIFIER PCL::UPDATE-CPL
    PCL::CHECKING-P PCL::CHECKING- COMMON-LISP::DEFSETF
-   COMMON-LISP::CAADAR COMMON-LISP::FORMATTER S::C-SET-HASHTABLE-PAD3
-   COMMON-LISP::SXHASH PCL::ASSQ PCL::SPEC-LL PCL::OPTIMIZE-SLOT-VALUE
-   PCL::INDENTATION PCL::DEFAULT COMMON-LISP::BOOLE-EQV
-   PCL::PARSE-QUALIFIER-PATTERN PCL::INITIALIZE-INTERNAL-SLOT-GFS
-   PCL::.PV-CELL. PCL::.METHOD-ARGS. COMMON-LISP::PROGV
-   PCL::POP-INITARGS PCL::INTERNAL-READER-FUNCTION PCL::SLOTD-TYPE
-   COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::CERROR
+   COMMON-LISP::CAADAR COMMON-LISP::FORMATTER
+   CSTRUCT::C-SET-HASHTABLE-PAD3 COMMON-LISP::SXHASH PCL::ASSQ
+   PCL::SPEC-LL PCL::OPTIMIZE-SLOT-VALUE PCL::INDENTATION PCL::DEFAULT
+   COMMON-LISP::BOOLE-EQV PCL::PARSE-QUALIFIER-PATTERN
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS PCL::.PV-CELL. PCL::.METHOD-ARGS.
+   COMMON-LISP::PROGV PCL::POP-INITARGS PCL::INTERNAL-READER-FUNCTION
+   PCL::SLOTD-TYPE COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::CERROR
    COMMON-LISP::STRING<= COMMON-LISP::STRING>= COMMON-LISP::STRING/=
    PCL::FIELD-TYPE PCL::ADD/REMOVE PCL::|SYSTEM:S-DATA SLOT17| PCL::NEW
    PCL::|(READER READERS)| COMMON-LISP::SIMPLE-BIT-VECTOR PCL::MAKE-CPD
    PCL::CACHE-LOCK-COUNT COMMON-LISP::BOOLE-NOR
    PCL::SET-FUNCTION-NAME-1 PCL::|(READER PREDICATE-NAME)|
-   COMMON-LISP::COMPILE-FILE-PATHNAME S::SET-ARRAY-DIMS
-   S::C-SET-HASHTABLE-PAD2 PCL::OPTIMIZE-GF-CALL COMMON-LISP::SEARCH
-   PCL::|COMPILER::BINDING class predicate|
+   COMMON-LISP::COMPILE-FILE-PATHNAME CSTRUCT::SET-ARRAY-DIMS
+   CSTRUCT::C-SET-HASHTABLE-PAD2 PCL::OPTIMIZE-GF-CALL
+   COMMON-LISP::SEARCH PCL::|COMPILER::BINDING class predicate|
    PCL::|(READER READER-FUNCTION)| COMMON-LISP::COPY-SYMBOL
    PCL::COMPARE-CLASSES-FUNCTION PCL::ARGUMENT-PRECEDENCE-ORDER
    PCL::|SYSTEM:S-DATA SLOT16| PCL::.METH-LIST.
    PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::SMC-WRAPPER
-   S::C-SET-HASHTABLE-PAD1 PCL::OPTIMIZE-GENERIC-FUNCTION-CALL
+   CSTRUCT::C-SET-HASHTABLE-PAD1 PCL::OPTIMIZE-GENERIC-FUNCTION-CALL
    COMMON-LISP::BOOLE-IOR COMMON-LISP::RATIO
    PCL::COMPILE-LAMBDA-DEFERRED PCL::SLOT-BOUNDP-USING-CLASS-DFUN
    PCL::KEYWORD-PARAMETERS
@@ -3846,12 +3871,13 @@
    COMMON-LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
    COMMON-LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
    COMMON-LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT
-   S::C-SET-SYMBOL-HPACK PCL::DEFSYSTEM COMMON-LISP::RPLACD
+   CSTRUCT::C-SET-SYMBOL-HPACK PCL::DEFSYSTEM COMMON-LISP::RPLACD
    PCL::SHOW-FREE-CACHE-VECTORS PCL::%STD-INSTANCE-SLOTS
    COMMON-LISP::DIVISION-BY-ZERO COMMON-LISP::&BODY
    PCL::|SYSTEM:S-DATA SLOT15| PCL::FUNCTION-APPLY
-   COMMON-LISP::CHAR-NOT-GREATERP PCL::CLASS+INITARGS S::C-FUNCTION-VV
-   PCL::LEGAL-LAMBDA-LIST-P S::C-SET-SYMBOL-HASH PCL::EARLY
+   COMMON-LISP::CHAR-NOT-GREATERP PCL::CLASS+INITARGS
+   CSTRUCT::C-FUNCTION-VV PCL::LEGAL-LAMBDA-LIST-P
+   CSTRUCT::C-SET-SYMBOL-HASH PCL::EARLY
    PCL::COMPLICATED-INSTANCE-CREATION-METHOD PCL::DECLARATION-NAME
    PCL::ARGUMENTS-LAMBDA-LIST PCL::OLD-WRAPPER COMMON-LISP::NRECONC
    COMMON-LISP::ASINH COMMON-LISP::ROW-MAJOR-AREF
@@ -3869,15 +3895,15 @@
    PCL::|(COMBINED-METHOD SHARED-INITIALIZE)|
    PCL::INITIALIZE-INFO-CACHED-RI-VALID-P
    PCL::INITIALIZE-INFO-CACHED-VALID-P PCL::INITIALIZE-INFO-RI-VALID-P
-   PCL::INITIALIZE-INFO-VALID-P S::C-SET-SYMBOL-STYPE COMMON-LISP::THE
-   PCL::NLAYOUT PCL::OLAYOUT PCL::CACHE-SIZE
+   PCL::INITIALIZE-INFO-VALID-P CSTRUCT::C-SET-SYMBOL-STYPE
+   COMMON-LISP::THE PCL::NLAYOUT PCL::OLAYOUT PCL::CACHE-SIZE
    PCL::|SYSTEM:S-DATA SLOT13| PCL::INITIAL-DISPATCH-P
    PCL::REAL-ADD-NAMED-METHOD PCL::MAKE-INSTANCE-1
    PCL::ONE-CLASS-ACCESSOR-TYPE PCL::GENERATOR PCL::PARSE
    COMMON-LISP::CDDAR WALKER::VARIABLE-LEXICAL-P
    PCL::CLASS-PRECEDENCE-DESCRIPTION COMMON-LISP::MOST-POSITIVE-FIXNUM
    PCL::KEYWORDS PCL::SLOT-NAME-FORM PCL::UNENCAPSULATED-FDEFINITION
-   PCL::APPLICABLE-P S::C-CFDATA-START
+   PCL::APPLICABLE-P CSTRUCT::C-CFDATA-START
    COMMON-LISP::MOST-POSITIVE-SHORT-FLOAT
    COMMON-LISP::MOST-POSITIVE-SINGLE-FLOAT
    COMMON-LISP::MOST-POSITIVE-DOUBLE-FLOAT
@@ -3890,25 +3916,26 @@
    PCL::*NEW-CLASS* PCL::MAKE-WRAPPER PCL::DECLARE-STRUCTURE
    COMMON-LISP::PSETQ PCL::USERS PCL::BOOTSTRAP-META-BRAID
    COMMON-LISP::EQUALP PCL::STATE PCL::INITIAL-LOCK-COUNT
-   S::C-SET-SYMBOL-NAME PCL::BOOTSTRAP-ACCESSOR-DEFINITION
+   CSTRUCT::C-SET-SYMBOL-NAME PCL::BOOTSTRAP-ACCESSOR-DEFINITION
    COMMON-LISP::SET PCL::INVALIDATE-WRAPPER COMMON-LISP::BOOLE-CLR
-   PCL::SLOT-BOUNDP-NORMAL S::C-CFDATA-DLIST PCL::%STD-INSTANCE-WRAPPER
-   PCL::|SYSTEM:S-DATA SLOT11| PCL::DEFAULT-TEST-CONVERTER
-   PCL::ALLOCATED PCL::NET PCL::SF-KEY COMMON-LISP::CATCH
-   PCL::EFFECTIVE-METHOD-LAMBDA COMMON-LISP::BYTE-POSITION
-   COMMON-LISP::LET PCL::INITIALIZE-INSTANCE-SIMPLE
-   PCL::DEFAULT-METHOD-FUNCTION COMMON-LISP::FILE-WRITE-DATE
-   PCL::METHOD-CALL- COMMON-LISP::SCHAR PCL::OLD-STD-P COMMON-LISP::GET
-   PCL::ADDED PCL::PCL-DESCRIBE SYSTEM::PACKAGE-INTERNAL
-   SYSTEM::PACKAGE-EXTERNAL PCL::OPTIMIZE-SET-SLOT-VALUE
-   PCL::CANONICAL-SLOT-NAME PCL::*OPTIMIZE-SPEED*
-   PCL::FUNCALLABLE-INSTANCE-CLOSURE-SIZE1 PCL::FAST-WRITER-METHOD
-   PCL::RCPL PCL::COMBIN PCL::CAM-STD-P COMMON-LISP::ACOS
-   PCL::REQUIREDS PCL::COPY-CACHING PCL::MCPL PCL::EMIT-BOUNDP-CHECK
-   COMMON-LISP::GET-OUTPUT-STREAM-STRING PCL::|SYSTEM:S-DATA SLOT10|
-   PCL::INITIAL-DISPATCH COMMON-LISP::BOOLE-AND
-   COMMON-LISP::NSET-DIFFERENCE PCL::OCNV PCL::SET-STANDARD-SVUC-METHOD
-   PCL::TYPE-MODIFIER COMMON-LISP::WRITE-LINE
+   PCL::SLOT-BOUNDP-NORMAL CSTRUCT::C-CFDATA-DLIST
+   PCL::%STD-INSTANCE-WRAPPER PCL::|SYSTEM:S-DATA SLOT11|
+   PCL::DEFAULT-TEST-CONVERTER PCL::ALLOCATED PCL::NET PCL::SF-KEY
+   COMMON-LISP::CATCH PCL::EFFECTIVE-METHOD-LAMBDA
+   COMMON-LISP::BYTE-POSITION COMMON-LISP::LET
+   PCL::INITIALIZE-INSTANCE-SIMPLE PCL::DEFAULT-METHOD-FUNCTION
+   COMMON-LISP::FILE-WRITE-DATE PCL::METHOD-CALL- COMMON-LISP::SCHAR
+   PCL::OLD-STD-P COMMON-LISP::GET PCL::ADDED PCL::PCL-DESCRIBE
+   SYSTEM::PACKAGE-INTERNAL SYSTEM::PACKAGE-EXTERNAL
+   PCL::OPTIMIZE-SET-SLOT-VALUE PCL::CANONICAL-SLOT-NAME
+   PCL::*OPTIMIZE-SPEED* PCL::FUNCALLABLE-INSTANCE-CLOSURE-SIZE1
+   PCL::FAST-WRITER-METHOD PCL::RCPL PCL::COMBIN PCL::CAM-STD-P
+   COMMON-LISP::ACOS PCL::REQUIREDS PCL::COPY-CACHING PCL::MCPL
+   PCL::EMIT-BOUNDP-CHECK COMMON-LISP::GET-OUTPUT-STREAM-STRING
+   PCL::|SYSTEM:S-DATA SLOT10| PCL::INITIAL-DISPATCH
+   COMMON-LISP::BOOLE-AND COMMON-LISP::NSET-DIFFERENCE PCL::OCNV
+   PCL::SET-STANDARD-SVUC-METHOD PCL::TYPE-MODIFIER
+   COMMON-LISP::WRITE-LINE
    PCL::FIND-CLASS-CELL-MAKE-INSTANCE-FUNCTION-KEYS
    COMMON-LISP::PACKAGE PCL::*DEFGENERIC-TIMES*
    PCL::|ONE-INDEX-DFUN-INFO SLOT2| PCL::GF-INFO-STATIC-C-A-M-EMF
@@ -3916,15 +3943,16 @@
    PCL::REAL-MAKE-METHOD-INITARGS-FORM PCL::SPECL-POSSIBLY-APPLICABLE-P
    COMMON-LISP::PRINT-NOT-READABLE-OBJECT PCL::RES COMMON-LISP::ATANH
    PCL::CONSTANT-CONVERTER PCL::TTAIL
-   PCL::MAKE-PV-TABLE-TYPE-DECLARATION S::*CHAR PCL::LDIR
-   PCL::TO-CACHE-VECTOR S::C-SET-SYMBOL-SFDEF S::C-SET-SYMBOL-GFDEF
-   S::C-SET-SYMBOL-MFLAG COMMON-LISP::PSETF
-   COMMON-LISP::SIMPLE-BIT-VECTOR-P PCL::RESET-INITIALIZE-INFO
-   PCL::ADD-CLASS-LIST PCL::PROCLAIM-DEFGENERIC COMMON-LISP::FLOATP
-   COMMON-LISP::BOOLE-SET COMMON-LISP::INVOKE-RESTART-INTERACTIVELY
-   PCL::INVOKE-EMF PCL::ESETF PCL::UPDATE-SLOTS-IN-PV
-   S::C-SET-SYMBOL-DBIND PCL::NEXT-WRAPPER-CACHE-NUMBER-INDEX
-   COMMON-LISP::PATHNAME COMMON-LISP::PROG2 S::C-SET-CFDATA-START
+   PCL::MAKE-PV-TABLE-TYPE-DECLARATION CSTRUCT::*CHAR PCL::LDIR
+   PCL::TO-CACHE-VECTOR CSTRUCT::C-SET-SYMBOL-SFDEF
+   CSTRUCT::C-SET-SYMBOL-GFDEF CSTRUCT::C-SET-SYMBOL-MFLAG
+   COMMON-LISP::PSETF COMMON-LISP::SIMPLE-BIT-VECTOR-P
+   PCL::RESET-INITIALIZE-INFO PCL::ADD-CLASS-LIST
+   PCL::PROCLAIM-DEFGENERIC COMMON-LISP::FLOATP COMMON-LISP::BOOLE-SET
+   COMMON-LISP::INVOKE-RESTART-INTERACTIVELY PCL::INVOKE-EMF PCL::ESETF
+   PCL::UPDATE-SLOTS-IN-PV CSTRUCT::C-SET-SYMBOL-DBIND
+   PCL::NEXT-WRAPPER-CACHE-NUMBER-INDEX COMMON-LISP::PATHNAME
+   COMMON-LISP::PROG2 CSTRUCT::C-SET-CFDATA-START
    PCL::INITIAL-DISPATCH-CACHE PCL::DISCARDED COMMON-LISP::PROG1
    PCL::MAKE-TRANSFORM PCL::PARAM
    PCL::FORWARD-REFERENCED-CLASS-SIMPLE-TYPEP-FN PCL::VALID-P
@@ -3934,7 +3962,8 @@
    COMMON-LISP::FIND-SYMBOL COMMON-LISP::PRINT PCL::REL-7-2
    PCL::MAKE-DISPATCH-LAMBDA PCL::TRUE PCL::EMIT-CACHING
    PCL::INTERNAL-READER-METHOD COMMON-LISP::HASH-TABLE-TEST
-   PCL::COPY-DISPATCH S::C-SET-CFDATA-DLIST PCL::GET-METHOD-FUNCTION
+   PCL::COPY-DISPATCH CSTRUCT::C-SET-CFDATA-DLIST
+   PCL::GET-METHOD-FUNCTION
    PCL::|PCL::STRUCTURE-SLOT-DEFINITION class predicate|
    PCL::|PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
    PCL::|PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
@@ -3944,7 +3973,7 @@
    PCL::*DEFAULT-PATHNAME-EXTENSIONS* PCL::CORAL-LOW COMMON-LISP::CDAAR
    PCL::*CHECK-CACHE-P* PCL::*EMPTY-CACHE* PCL::LOCATION
    PCL::DEFINITION-SOURCE-MIXIN-SIMPLE-TYPEP-FN PCL::SUBS
-   S::C-SET-T-MOFFSET COMMON-LISP::ARRAYP COMMON-LISP::PROG*
+   CSTRUCT::C-SET-T-MOFFSET COMMON-LISP::ARRAYP COMMON-LISP::PROG*
    PCL::LEGALP COMMON-LISP::WRITE COMMON-LISP::*STANDARD-OUTPUT*
    PCL::CLASS2 COMMON-LISP::INLINE PCL::GCL_PCL_DLISP2
    PCL::*FREE-HASH-TABLES* PCL::DEFAULT-CONSTANT-CONVERTER
@@ -3953,7 +3982,7 @@
    COMMON-LISP::DECLARATION PCL::*EARLY-GENERIC-FUNCTIONS*
    PCL::PRECOMPUTE-P PCL::STD-P PCL::MAKE-TYPE-PREDICATE
    PCL::CAPITALIZE-WORDS PCL::GET-WRAPPER PCL::SET-WRAPPER
-   PCL::NEW-WRAPPER S::C-SET-BIGNUM-MPZ_T
+   PCL::NEW-WRAPPER CSTRUCT::C-SET-BIGNUM-MPZ_T
    PCL::WITH-MAKE-INSTANCE-FUNCTION-VALID-P-CHECK PCL::DECL
    PCL::GET-BUILT-IN-CLASS-SYMBOL PCL::GET-BUILT-IN-WRAPPER-SYMBOL
    PCL::FGEN-SYSTEM PCL::NEQ COMMON-LISP::FORCE-OUTPUT
@@ -4067,27 +4096,28 @@
    PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
    PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
    PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-   COMMON-LISP::SPECIAL-OPERATOR-P PCL::PREDICATE S::C-FIXNUM-FLOAT-==
-   PCL::MT PCL::DEFAULT-METHOD-ONLY-P S::C-SET-STREAM-FLAGS
-   COMMON-LISP::DECF COMMON-LISP::MAKE-RANDOM-STATE PCL::SAUT-PROTOTYPE
-   PCL::IT PCL::*STRUCTURE-TABLE* PCL::*BUILT-IN-CLASSES* PCL::FT
-   PCL::CT PCL::NUMBER-OF-REQUIREDS COMMON-LISP::ED PCL::EXCL-LOW
+   COMMON-LISP::SPECIAL-OPERATOR-P PCL::PREDICATE
+   CSTRUCT::C-FIXNUM-FLOAT-== PCL::MT PCL::DEFAULT-METHOD-ONLY-P
+   CSTRUCT::C-SET-STREAM-FLAGS COMMON-LISP::DECF
+   COMMON-LISP::MAKE-RANDOM-STATE PCL::SAUT-PROTOTYPE PCL::IT
+   PCL::*STRUCTURE-TABLE* PCL::*BUILT-IN-CLASSES* PCL::FT PCL::CT
+   PCL::NUMBER-OF-REQUIREDS COMMON-LISP::ED PCL::EXCL-LOW
    COMMON-LISP::BOOLE-1 PCL::FILL-CACHE-P PCL::*EARLY-FUNCTIONS*
    PCL::|PCL::METAOBJECT class predicate| PCL::|TWO-CLASS SLOT4|
    COMMON-LISP::BOOLE-NAND PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL
-   S::C-SET-ARRAY-OFFSET PCL::*BUILT-IN-CLASS-SYMBOLS* S::C-SET-T-MRANK
-   PCL::FROM-LOCATION PCL::*PVS* PCL::VALUE PCL::QUAL
-   PCL::MAKE-BOUNDP-METHOD-FUNCTION COMMON-LISP::REAL COMMON-LISP::&AUX
-   PCL::DEFAULT-LIMIT-FN PCL::IBCL-LOW S::C-FIXNUM-DOUBLE->
-   PCL::MAP-ALL-GENERIC-FUNCTIONS
+   CSTRUCT::C-SET-ARRAY-OFFSET PCL::*BUILT-IN-CLASS-SYMBOLS*
+   CSTRUCT::C-SET-T-MRANK PCL::FROM-LOCATION PCL::*PVS* PCL::VALUE
+   PCL::QUAL PCL::MAKE-BOUNDP-METHOD-FUNCTION COMMON-LISP::REAL
+   COMMON-LISP::&AUX PCL::DEFAULT-LIMIT-FN PCL::IBCL-LOW
+   CSTRUCT::C-FIXNUM-DOUBLE-> PCL::MAP-ALL-GENERIC-FUNCTIONS
    PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
    PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
    PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
    PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|
    PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
    PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
-   COMMON-LISP::GETHASH PCL::CALLS S::C-FCOMPLEX-FIXNUM-==
-   S::C-DCOMPLEX-FIXNUM-== PCL::NAMES COMMON-LISP::CLEAR-OUTPUT
+   COMMON-LISP::GETHASH PCL::CALLS CSTRUCT::C-FCOMPLEX-FIXNUM-==
+   CSTRUCT::C-DCOMPLEX-FIXNUM-== PCL::NAMES COMMON-LISP::CLEAR-OUTPUT
    PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
    PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
    PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|
@@ -4097,10 +4127,10 @@
    PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|
    PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
    COMMON-LISP::COMPLEXP PCL::MAKE-PATHNAME-INTERNAL COMMON-LISP::STEP
-   S::*FIXNUM PCL::|(WRITER SOURCE)| PCL::SIMPLE-P PCL::|CACHE SLOT9|
-   PCL::RESET-CLASS-INITIALIZE-INFO-1 PCL::FALSE
+   CSTRUCT::*FIXNUM PCL::|(WRITER SOURCE)| PCL::SIMPLE-P
+   PCL::|CACHE SLOT9| PCL::RESET-CLASS-INITIALIZE-INFO-1 PCL::FALSE
    PCL::*SGF-ARG-INFO-INDEX* PCL::SCASE COMMON-LISP::*STANDARD-INPUT*
-   S::C-SET-STREAM-BUFFER PCL::NAMEP PCL::MAKE-TRAMPOLINE
+   CSTRUCT::C-SET-STREAM-BUFFER PCL::NAMEP PCL::MAKE-TRAMPOLINE
    PCL::DEFAULT-STRUCTURE-TYPE PCL::COPY-CHECKING PCL::MCASE
    PCL::COPY-INSTANCE-INTERNAL COMMON-LISP::APPLY
    PCL::PRECOMPUTE-EFFECTIVE-METHODS PCL::*EXPORTS*
@@ -4108,9 +4138,9 @@
    PCL::DEFAULT-INITARGS-METHODS PCL::PV-CELL PCL::CLASS-SUBS
    PCL::DISPATCH PCL::GENERIC-FUNCTION-PRETTY-ARGLIST PCL::DSLOTDS
    PCL::ESLOTDS COMMON-LISP::ECASE PCL::DFUN-WRAPPERS-TAIL
-   COMMON-LISP::CCASE COMMON-LISP::&REST S::C-FCOMPLEX-DOUBLE-==
-   S::C-DCOMPLEX-DOUBLE-== COMMON-LISP::FCEILING PCL::|CACHE SLOT8|
-   COMMON-LISP::CLRHASH COMMON-LISP::PARSE-INTEGER
+   COMMON-LISP::CCASE COMMON-LISP::&REST CSTRUCT::C-FCOMPLEX-DOUBLE-==
+   CSTRUCT::C-DCOMPLEX-DOUBLE-== COMMON-LISP::FCEILING
+   PCL::|CACHE SLOT8| COMMON-LISP::CLRHASH COMMON-LISP::PARSE-INTEGER
    PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
    PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
    PCL::EFFECTIVE-METHOD-GENSYM-9 COMMON-LISP::LOGANDC2
@@ -4126,35 +4156,37 @@
    COMMON-LISP::*COMPILE-PRINT* COMMON-LISP::ODDP
    COMMON-LISP::PACKAGE-SHADOWING-SYMBOLS PCL::LOAD-PCL PCL::HEAD
    PCL::NAME-OR-MODULE PCL::GF-CALL PCL::CHOICE COMMON-LISP::STRING>
-   PCL::*COMPILER-SPEED* S::C-T-MELTSIZE
+   PCL::*COMPILER-SPEED* CSTRUCT::C-T-MELTSIZE
    PCL::FIND-CLASS-PREDICATE-FROM-CELL PCL::FIND-CLASS-FROM-CELL
    COMMON-LISP::USER-HOMEDIR-PATHNAME COMMON-LISP::LAST
    PCL::EARLY-SLOT-DEFINITION-LOCATION PCL::BRAID-P PCL::FROM
-   S::C-SET-ARRAY-RANK S::C-HASHTABLE-TEST COMMON-LISP::BIT-ANDC2
-   PCL::|CACHE SLOT6| PCL::LOAD-ENV PCL::EFFECTIVE-METHOD-GENSYM-7
+   CSTRUCT::C-SET-ARRAY-RANK CSTRUCT::C-HASHTABLE-TEST
+   COMMON-LISP::BIT-ANDC2 PCL::|CACHE SLOT6| PCL::LOAD-ENV
+   PCL::EFFECTIVE-METHOD-GENSYM-7
    PCL::*ALLOW-EXPERIMENTAL-SPECIALIZERS-P* PCL::WRAPPER-FOR-STRUCTURE
    PCL::COMPILED PCL::TEM COMMON-LISP::HANDLER-BIND ITERATE::ITERATE*
    PCL::EMIT-CHECKING PCL::SKIP-WHEN-INSTANCE-BOUNDP
    PCL::*PV-KEY-TO-PV-TABLE-TABLE* PCL::N-POPPED COMMON-LISP::REM
    PCL::ARG-INFO-METATYPES COMMON-LISP::MAKE-SYMBOL
-   COMMON-LISP::MAPHASH S::C-CFDATA-PROF COMMON-LISP::STRING= PCL::STR
-   COMMON-LISP::ASIN PCL::|CACHE SLOT5| PCL::EFFECTIVE-METHOD-GENSYM-6
-   PCL::BOUNDPS COMMON-LISP::SQRT PCL::PREVIOUS-SLOT-NAMES
-   PCL::|(BOUNDP OPTIONS)| PCL::|(BOUNDP METHODS)| PCL::PROTO-NEW-CLASS
+   COMMON-LISP::MAPHASH CSTRUCT::C-CFDATA-PROF COMMON-LISP::STRING=
+   PCL::STR COMMON-LISP::ASIN PCL::|CACHE SLOT5|
+   PCL::EFFECTIVE-METHOD-GENSYM-6 PCL::BOUNDPS COMMON-LISP::SQRT
+   PCL::PREVIOUS-SLOT-NAMES PCL::|(BOUNDP OPTIONS)|
+   PCL::|(BOUNDP METHODS)| PCL::PROTO-NEW-CLASS
    PCL::DEFAULT-CODE-CONVERTER COMMON-LISP::CDR COMMON-LISP::PROG
    PCL::VARS PCL::ARG-INFO-NKEYS PCL::*PCL-SYSTEM-DATE*
    PCL::METHODS-CONVERTER COMMON-LISP::ROUND PCL::|CACHE SLOT4|
    COMMON-LISP::STRING< PCL::MAKE-CACHING-DFUN
    PCL::EFFECTIVE-METHOD-GENSYM-5 PCL::PATH
    PCL::GENERIC-CLOBBERS-FUNCTION PCL::EMIT-N-N-WRITERS
-   PCL::MEC-ALL-CLASS-LISTS S::C-HASHTABLE-NENT
+   PCL::MEC-ALL-CLASS-LISTS CSTRUCT::C-HASHTABLE-NENT
    COMMON-LISP::STRING-LEFT-TRIM PCL::ARG-INFO-NUMBER-REQUIRED
-   COMMON-LISP::TAILP S::C-CFDATA-NAME PCL::ARG-INFO-KEYWORDS
+   COMMON-LISP::TAILP CSTRUCT::C-CFDATA-NAME PCL::ARG-INFO-KEYWORDS
    PCL::FUNCTION-NAME PCL::DESCRIPTION
    PCL::|(BOUNDP DIRECT-SUPERCLASSES)|
    PCL::|(BOUNDP DIRECT-SUBCLASSES)| COMMON-LISP::CHARACTER
-   COMMON-LISP::CHARACTERP S::C-FIXNUM-FCOMPLEX-==
-   S::C-FIXNUM-DCOMPLEX-== COMMON-LISP::FILE-ERROR-PATHNAME
+   COMMON-LISP::CHARACTERP CSTRUCT::C-FIXNUM-FCOMPLEX-==
+   CSTRUCT::C-FIXNUM-DCOMPLEX-== COMMON-LISP::FILE-ERROR-PATHNAME
    PCL::MAKE-FIND-CLASS-CELL COMMON-LISP::SYMBOL-PLIST
    PCL::METACLASS-NAME PCL::|(BOUNDP BOUNDP-FUNCTION)|
    PCL::REAL-INVALID-METHOD-ERROR COMMON-LISP::Y-OR-N-P
@@ -4179,11 +4211,11 @@
    PCL::WRAPPER-CLASS-SLOTS ITERATE::*ITERATE-WARNINGS*
    PCL::MAKE-INSTANCE-FUNCTION-COMPLEX PCL::CLASS-NO-OF-INSTANCE-SLOTS
    PCL::FIND-CLASS-CELL-PREDICATE PCL::FIND-CLASS-PREDICATE
-   PCL::.CALLS. S::C-SET-CFDATA-PROF PCL::MAYBE-APP-P PCL::NAME2
+   PCL::.CALLS. CSTRUCT::C-SET-CFDATA-PROF PCL::MAYBE-APP-P PCL::NAME2
    PCL::|(BOUNDP FAST-FUNCTION)| COMMON-LISP::IMPORT COMMON-LISP::CDAR
    PCL::*SGF-NAME-INDEX* PCL::SS COMMON-LISP::RATIONALIZE
-   S::C-SET-ARRAY-ELTTYPE PCL::NAME1 PCL::|CACHE SLOT1| PCL::FORMS
-   PCL::EFFECTIVE-METHOD-GENSYM-2 PCL::SC PCL::ALIST-CELL
+   CSTRUCT::C-SET-ARRAY-ELTTYPE PCL::NAME1 PCL::|CACHE SLOT1|
+   PCL::FORMS PCL::EFFECTIVE-METHOD-GENSYM-2 PCL::SC PCL::ALIST-CELL
    PCL::KLIST-CELL PCL::EXPAND-DEFCLASS PCL::FSC-P
    PCL::FAST-BOUNDP-METHOD PCL::DATA PCL::COPY-ONE-CLASS
    COMMON-LISP::HASH-TABLE-P COMMON-LISP::FLOATING-POINT-OVERFLOW
@@ -4193,20 +4225,20 @@
    PCL::*CACHE-EXPAND-THRESHOLD* PCL::ARG-INFO-PRECEDENCE
    PCL::NET-CONSTANT-CONVERTER PCL::STRUCTURE-OBJECT-P
    COMMON-LISP::CASE COMMON-LISP::BREAK PCL::PV-TABLEP
-   PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME S::C-SET-SYMBOL-PAD3
-   COMMON-LISP::MAKE-CONCATENATED-STREAM S::C-FUNCTION-DATA
-   PCL::|CACHE SLOT0| PCL::ICU S::C-T-MELTMODE PCL::EXTENSION
+   PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME CSTRUCT::C-SET-SYMBOL-PAD3
+   COMMON-LISP::MAKE-CONCATENATED-STREAM CSTRUCT::C-FUNCTION-DATA
+   PCL::|CACHE SLOT0| PCL::ICU CSTRUCT::C-T-MELTMODE PCL::EXTENSION
    PCL::EFFECTIVE-METHOD-GENSYM-1 PCL::|(READER METHOD)| PCL::TRANS
    COMMON-LISP::COMPILE COMMON-LISP::+++
    PCL::GENERIC-FUNCTION-SIMPLE-TYPEP-FN PCL::USES PCL::ECD-CLASS-NAME
    COMMON-LISP::ATAN COMMON-LISP::STRING-RIGHT-TRIM
    PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS PCL::ALL-APPLICABLE-P
-   PCL::|(BOUNDP FROM-DEFCLASS-P)| S::C-SET-CFDATA-NAME
+   PCL::|(BOUNDP FROM-DEFCLASS-P)| CSTRUCT::C-SET-CFDATA-NAME
    PCL::|(BOUNDP DFUN-STATE)| PCL::NEW-SLOT PCL::*FREE-CACHES*
    PCL::GF-LL COMMON-LISP::SHORT-FLOAT-EPSILON
    COMMON-LISP::SHORT-FLOAT-NEGATIVE-EPSILON PCL::MAKE-CACHING
    PCL::|PCL::DEFINITION-SOURCE-MIXIN class predicate|
-   PCL::FMC-ARG-INFO S::C-SET-SYMBOL-PAD2 PCL::COMPARE
+   PCL::FMC-ARG-INFO CSTRUCT::C-SET-SYMBOL-PAD2 PCL::COMPARE
    PCL::*PV-TABLE-CACHE-UPDATE-INFO* PCL::EFFECTIVE-METHOD-GENSYM-0
    COMMON-LISP::FILL-POINTER PCL::REAL-MAKE-A-METHOD
    COMMON-LISP::COUNT-IF PCL::MAKE-WRAPPER-INTERNAL
@@ -4230,18 +4262,18 @@
    COMMON-LISP::SBIT PCL::|(BOUNDP SLOT-DEFINITION)|
    COMMON-LISP::SECOND PCL::EARLY-ADD-NAMED-METHOD PCL::CACHE-P
    PCL::GCL_PCL_SLOTS_BOOT PCL::METHOD-PRETTY-ARGLIST
-   S::C-SET-CHARACTER-FONT
+   CSTRUCT::C-SET-CHARACTER-FONT
    PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION
    PCL::|(BOUNDP LAMBDA-LIST)| COMMON-LISP::COPY-SEQ
-   S::C-SET-CHARACTER-BITS PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
-   COMMON-LISP::WITH-OPEN-FILE S::C-PACKAGE-USELIST
-   S::C-PACKAGE-USEDBYLIST PCL::RUN-TIME-VALS PCL::TYPES-REV
+   CSTRUCT::C-SET-CHARACTER-BITS PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
+   COMMON-LISP::WITH-OPEN-FILE CSTRUCT::C-PACKAGE-USELIST
+   CSTRUCT::C-PACKAGE-USEDBYLIST PCL::RUN-TIME-VALS PCL::TYPES-REV
    PCL::ARG-INFO-READER COMMON-LISP::EXPORT
    PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION
    PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::NEW-TAIL
    PCL::|(BOUNDP FUNCTION)| PCL::|(BOUNDP GENERIC-FUNCTION)|
-   PCL::MAKE-DISPATCH S::C-PATHNAME-VERSION COMMON-LISP::DOCUMENTATION
-   COMMON-LISP::*COMPILE-FILE-PATHNAME*
+   PCL::MAKE-DISPATCH CSTRUCT::C-PATHNAME-VERSION
+   COMMON-LISP::DOCUMENTATION COMMON-LISP::*COMPILE-FILE-PATHNAME*
    COMMON-LISP::*COMPILE-FILE-TRUENAME* PCL::*THE-WRAPPER-OF-ARRAY*
    PCL::NON-ARG-P PCL::TYPES-FROM-ARGUMENTS PCL::GF-KEYWORDS
    COMMON-LISP::POSITION-IF PCL::EMIT-ONE-INDEX-READERS
@@ -4259,7 +4291,7 @@
    PCL::EXPAND-MAKE-INSTANCE-FORM PCL::ACCESSOR-CLASS PCL::CORAL
    PCL::*PCL-DIRECTORY*
    PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRECOMPILED
-   PCL::KEYWORD-SPEC-NAME S::C-T-CFW PCL::TEST-CONVERTER
+   PCL::KEYWORD-SPEC-NAME CSTRUCT::C-T-CFW PCL::TEST-CONVERTER
    COMMON-LISP::BOOLE-ANDC1 PCL::DFUN-UPDATE PCL::*INITIAL-PV-TABLE*
    COMMON-LISP::FLOATING-POINT-INVALID-OPERATION COMMON-LISP::CDAAAR
    PCL::KEY-LIST COMMON-LISP::CONSP PCL::STRUCTURE-FUNCTIONS-EXIST-P
@@ -4273,9 +4305,9 @@
    PCL::CACHE-OVERFLOW PCL::LOOSE COMMON-LISP::MAPC
    PCL::*THE-WRAPPER-OF-RATIO*
    PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT3| PCL::SLOT-VALUE-NORMAL
-   PCL::FGEN-TEST S::C-HASHTABLE-RHTHRESH PCL::LOAD-SHORT-DEFCOMBIN
-   PCL::COPY-DEFAULT-METHOD-ONLY PCL::PRETTY-CLASS
-   COMMON-LISP::SYNONYM-STREAM PCL::COMPUTE-LAYOUT
+   PCL::FGEN-TEST CSTRUCT::C-HASHTABLE-RHTHRESH
+   PCL::LOAD-SHORT-DEFCOMBIN PCL::COPY-DEFAULT-METHOD-ONLY
+   PCL::PRETTY-CLASS COMMON-LISP::SYNONYM-STREAM PCL::COMPUTE-LAYOUT
    PCL::ECD-OTHER-INITARGS PCL::|(BOUNDP INITIAL-METHODS)|
    PCL::NO-METHODS-DFUN-INFO PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P
    PCL::BRAID PCL::|(BOUNDP SLOT-NAME)|
@@ -4293,7 +4325,7 @@
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRAPPER)| PCL::VALS PCL::ORIG
    COMMON-LISP::TRACE PCL::ARGS SYSTEM::NANI PCL::CACHING-MISS
    PCL::SHOW-DFUN-COSTS COMMON-LISP::TANH PCL::|(BOUNDP INITFORM)|
-   PCL::CLASS-OR-NAME S::C-FUNCTION-PLIST
+   PCL::CLASS-OR-NAME CSTRUCT::C-FUNCTION-PLIST
    PCL::*THE-WRAPPER-OF-RATIONAL* PCL::|INITIALIZE-INFO SLOT10|
    PCL::OUTERS PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT1|
    COMMON-LISP::UNLESS COMMON-LISP::FFLOOR PCL::LOAD-FUNCTION-GENERATOR
@@ -4318,7 +4350,7 @@
    PCL::|(BOUNDP ARGUMENTS-LAMBDA-LIST)| PCL::SCAN-SETF
    PCL::UPDATE-INITIALIZE-INFO-INTERNAL
    PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD PCL::*THE-CLASS-NULL*
-   S::C-DOUBLE-DOUBLE-==
+   CSTRUCT::C-DOUBLE-DOUBLE-==
    PCL::MAKE-LOAD-WITHOUT-DEPENDENCIES-TRANSFORMATION PCL::WR
    PCL::SORT-SLOTS PCL::COPY-SLOTS PCL::UPDATE-SLOTS COMMON-LISP::CADDR
    PCL::*THE-CLASS-LIST* COMMON-LISP::INVOKE-RESTART PCL::SLOTS-FETCHER
@@ -4422,13 +4454,13 @@
    PCL::SHARED-INITIALIZE-NIL-FUNCTION PCL::SHARED-INITIALIZE-METHODS
    COMMON-LISP::STRING-STREAM COMMON-LISP::UNWIND-PROTECT PCL::NPOP
    PCL::WFT-WRAPPER2 PCL::DEPENDENT-UPDATE-MIXIN PCL::APPL PCL::.PV.
-   PCL::CONSTRUCTOR PCL::READER-SYM S::C-DOUBLE-FIXNUM-==
+   PCL::CONSTRUCTOR PCL::READER-SYM CSTRUCT::C-DOUBLE-FIXNUM-==
    PCL::COPY-CACHE-INTERNAL PCL::*GENERIC-FUNCTION-FIXUPS*
    PCL::FAST-INSTANCE-BOUNDP-P COMMON-LISP::FIND-IF-NOT
-   S::C-CHARACTER-FONT PCL::EMIT-SLOT-READ-FORM COMMON-LISP::WARNING
-   PCL::MAKE-CONSTANT-FUNCTION PCL::COMPUTE-CALLS
+   CSTRUCT::C-CHARACTER-FONT PCL::EMIT-SLOT-READ-FORM
+   COMMON-LISP::WARNING PCL::MAKE-CONSTANT-FUNCTION PCL::COMPUTE-CALLS
    PCL::CONVERT-TO-SYSTEM-TYPE COMMON-LISP::STREAMP PCL::PYR-PATCHES
-   S::C-CHARACTER-BITS PCL::REAL-ENSURE-GF-INTERNAL
+   CSTRUCT::C-CHARACTER-BITS PCL::REAL-ENSURE-GF-INTERNAL
    PCL::SYSTEM-DESCRIPTION PCL::*MAKE-INSTANCE-FUNCTION-KEYS*
    PCL::%SVREF COMMON-LISP::UNDEFINED-FUNCTION PCL::.DOLIST-CAREFULLY.
    PCL::AFTER-P PCL::IDENTITY-WITH-ONE-ARGUMENT
@@ -4446,7 +4478,7 @@
    COMMON-LISP::LOGNOT COMMON-LISP::BIT-NAND COMMON-LISP::MAX
    PCL::*LIST-ELEMENTS ITERATE::PLIST-ELEMENTS
    PCL::|(BOUNDP CLASS-PRECEDENCE-LIST)| PCL::GATHERING1
-   ITERATE::GATHERING S::C-DOUBLE-FIXNUM-> PCL::EQL-TEST
+   ITERATE::GATHERING CSTRUCT::C-DOUBLE-FIXNUM-> PCL::EQL-TEST
    PCL::OLD-VECTOR PCL::SPEC-LIST COMMON-LISP::LOGNOR
    PCL::MAKE-CALLS-TYPE-DECLARATION PCL::FORM-LIST
    COMMON-LISP::COPY-LIST PCL::SET-FUNCTION-PRETTY-ARGLIST
@@ -4454,11 +4486,11 @@
    COMMON-LISP::BIT-VECTOR PCL::NEW-VECTOR PCL::UPDATE-GF-DFUN
    PCL::UPDATE-DFUN COMMON-LISP::FINISH-OUTPUT
    COMMON-LISP::MUFFLE-WARNING PCL::POSQ PCL::NO-METHODS-
-   COMMON-LISP::LCM COMMON-LISP::SIMPLE-ARRAY S::C-STREAM-FLAGS
+   COMMON-LISP::LCM COMMON-LISP::SIMPLE-ARRAY CSTRUCT::C-STREAM-FLAGS
    PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE PCL::DFUN-LIST
    COMMON-LISP::SAFETY PCL::CURRENT-SLOTDS COMMON-LISP::EVAL-WHEN
    PCL::*INITIALIZE-INFO-CACHE-INITARGS* PCL::CALL-LIST PCL::SUB
-   PCL::CASE-LIST COMMON-LISP::MAKE-LIST S::C-DOUBLE-FLOAT->
+   PCL::CASE-LIST COMMON-LISP::MAKE-LIST CSTRUCT::C-DOUBLE-FLOAT->
    COMMON-LISP::MAKUNBOUND
    PCL::|PCL::ACCESSOR-DFUN-INFO class predicate|
    PCL::GET-DFUN-CONSTRUCTOR PCL::TREE
@@ -4471,16 +4503,17 @@
    PCL::TRACE-METHOD-INTERNAL COMMON-LISP::CAAAR PCL::PORT PCL::PRED
    PCL::FREE PCL::|(BOUNDP READER-FUNCTION)|
    PCL::PLIST-MIXIN-SIMPLE-TYPEP-FN PCL::MAKE-ONE-INDEX
-   S::C-SET-CHARACTER-NAME PCL::PRINTING-RANDOM-THING-INTERNAL
-   PCL::COPY-PV-TABLE S::ADJUSTABLE-ARRAY PCL::FORMAT-CONTROL
+   CSTRUCT::C-SET-CHARACTER-NAME PCL::PRINTING-RANDOM-THING-INTERNAL
+   PCL::COPY-PV-TABLE CSTRUCT::ADJUSTABLE-ARRAY PCL::FORMAT-CONTROL
    COMMON-LISP::COMPILED-FUNCTION-P
    PCL::MAKE-BUILT-IN-WRAPPER-OF-BODY-1 PCL::TRACE-EMF-CALL
    PCL::CLASS-MIGHT-PRECEDE-P WALKER::DEFINE-WALKER-TEMPLATE
    PCL::NO-METHODS-CACHE PCL::SPECS PCL::FROM-DEFCLASS-P
    COMMON-LISP::ARRAY-TOTAL-SIZE COMMON-LISP::PPRINT-LOGICAL-BLOCK
    PCL::PCL PCL::CACHED-INITARGS-FORM-LIST PCL::CACHE-VECTOR-LOCK-COUNT
-   PCL::SPECIALIZERS PCL::*INITIALIZE-INFO-CACHE-INFO* S::C-SET-T-XX
-   PCL::KCL PCL::|(FAST-READER-METHOD CLASS CLASS-EQ-SPECIALIZER)|
+   PCL::SPECIALIZERS PCL::*INITIALIZE-INFO-CACHE-INFO*
+   CSTRUCT::C-SET-T-XX PCL::KCL
+   PCL::|(FAST-READER-METHOD CLASS CLASS-EQ-SPECIALIZER)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
    COMMON-LISP::BOUNDP PCL::ALLOCP PCL::GCL
    COMMON-LISP::DEFINE-SETF-EXPANDER PCL::IBCL
@@ -4522,14 +4555,15 @@
    PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS) NIL|
    PCL::|MAKE-INSTANCE CLASS-EQ-SPECIALIZER (:CLASS) NIL|
    PCL::SLOT-UNBOUND-INTERNAL COMMON-LISP::LISP-IMPLEMENTATION-TYPE
-   PCL::SYSTEM PCL::DIRECT-SUPERS S::C-STREAM-BUFFER
+   PCL::SYSTEM PCL::DIRECT-SUPERS CSTRUCT::C-STREAM-BUFFER
    PCL::COMPATIBLE-META-CLASS-CHANGE-P PCL::ACCESSOR-TYPE
-   ITERATE::LIST-TAILS S::C-SET-T-TP S::C-SET-T-TT S::C-SET-T-T
-   PCL::DIRECT-SLOTS PCL::SPECIALIZERS-FORM PCL::MAKE-ONE-CLASS
-   PCL::FAST-LEXICAL-METHOD-FUNCTIONS PCL::SPECIALIZER-SIMPLE-TYPEP-FN
+   ITERATE::LIST-TAILS CSTRUCT::C-SET-T-TP CSTRUCT::C-SET-T-TT
+   CSTRUCT::C-SET-T-T PCL::DIRECT-SLOTS PCL::SPECIALIZERS-FORM
+   PCL::MAKE-ONE-CLASS PCL::FAST-LEXICAL-METHOD-FUNCTIONS
+   PCL::SPECIALIZER-SIMPLE-TYPEP-FN
    PCL::SPECIALIZER-WITH-OBJECT-SIMPLE-TYPEP-FN PCL::GET-FUNCTION
    PCL::MEMF-CODE-CONVERTER PCL::METHOD-PROTOTYPE-FOR-GF
-   S::C-FUNCTION-MAXARG PCL::PLIST-VALUE PCL::SET-SYSTEM
+   CSTRUCT::C-FUNCTION-MAXARG PCL::PLIST-VALUE PCL::SET-SYSTEM
    PCL::GET-SYSTEM
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::FROZEN)|
    PCL::*SLOTD-WRITER-FUNCTION-STD-P* PCL::CHECKING-LIMIT-FN
@@ -4546,14 +4580,14 @@
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::MACROS)|
    COMMON-LISP::ADJOIN COMMON-LISP::ENSURE-DIRECTORIES-EXIST PCL::SPECL
    PCL::|(FAST-READER-METHOD SLOT-OBJECT OVERFLOW)|
-   COMMON-LISP::PPRINT-FILL COMMON-LISP::SIMPLE-ERROR S::C-SET-T-PD
-   PCL::COPY PCL::SHARED-INITFNS
+   COMMON-LISP::PPRINT-FILL COMMON-LISP::SIMPLE-ERROR
+   CSTRUCT::C-SET-T-PD PCL::COPY PCL::SHARED-INITFNS
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::ARG-TYPES)|
    PCL::STRING-APPEND PCL::NEW-VALUE PCL::NEW-VALUES
    PCL::EMIT-READER/WRITER PCL::FORM COMMON-LISP::COSH
    PCL::|(FAST-READER-METHOD PCL-CLASS WRAPPER)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT WRAPPER)|
-   S::C-SET-RANDOM-STATE PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN
+   CSTRUCT::C-SET-RANDOM-STATE PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN
    PCL::SUPPLIED-META PCL::|(FAST-READER-METHOD SLOT-OBJECT NLINES)|
    COMMON-LISP::REVERSE PCL::OTHERS PCL::TRAP PCL::INDEXES
    PCL::EXACT-CLASS-SPECIALIZER-P
@@ -4565,18 +4599,19 @@
    PCL::.IGNORE. PCL::T1 PCL::S1 PCL::ACCESSOR-NAME
    PCL::PRINTING-RANDOM-THING PCL::LOSE PCL::COMP-ENV PCL::PROTO-METHOD
    COMMON-LISP::SPEED PCL::DETERMINED-TO-BE PCL::METHOD-GROUP-SPECIFIER
-   S::C-SET-HASHTABLE-MAX_ENT PCL::SPECIALIZERP S::C-FUNCTION-MINARG
-   PCL::NOPT PCL::INNER PCL::WRITER-METHOD COMMON-LISP::EQ PCL::ELEMENT
-   S::C-SET-T-H PCL::I1
+   CSTRUCT::C-SET-HASHTABLE-MAX_ENT PCL::SPECIALIZERP
+   CSTRUCT::C-FUNCTION-MINARG PCL::NOPT PCL::INNER PCL::WRITER-METHOD
+   COMMON-LISP::EQ PCL::ELEMENT CSTRUCT::C-SET-T-H PCL::I1
    PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT ARG-INFO)|
    PCL::|(FAST-READER-METHOD SLOT-CLASS INITIALIZE-INFO)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
    PCL::EMIT-READER/WRITER-MACRO PCL::|(SETF GF-PRETTY-ARGLIST)|
    COMMON-LISP::UNBOUND-SLOT PCL::SLOT-VECTOR-SYMBOL PCL::C1
-   PCL::FGEN-GENSYMS S::C-SET-T-FW S::C-SET-T-F S::C-SET-T-FF
-   PCL::TRACE-METHOD COMMON-LISP::ENOUGH-NAMESTRING PCL::METATYPES
-   PCL::PRETTY-NAME PCL::|(SETF GENERIC-FUNCTION-METHODS)|
+   PCL::FGEN-GENSYMS CSTRUCT::C-SET-T-FW CSTRUCT::C-SET-T-F
+   CSTRUCT::C-SET-T-FF PCL::TRACE-METHOD COMMON-LISP::ENOUGH-NAMESTRING
+   PCL::METATYPES PCL::PRETTY-NAME
+   PCL::|(SETF GENERIC-FUNCTION-METHODS)|
    PCL::|(SETF GENERIC-FUNCTION-INITIAL-METHODS)|
    PCL::|(SETF GENERIC-FUNCTION-DECLARATIONS)| PCL::WRITER-NAME
    PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION-FAST PCL::TRACED-METHOD
@@ -4590,19 +4625,21 @@
    COMMON-LISP::ARRAY-DIMENSION PCL::INNERS COMMON-LISP::ADJUST-ARRAY
    COMMON-LISP::SINGLE-FLOAT ITERATE::JOINING PCL::PREVIOUS
    PCL::..UNSPECIFIC-ARG.. PCL::MORE PCL::ROOT
-   S::C-SET-PATHNAME-DIRECTORY
+   CSTRUCT::C-SET-PATHNAME-DIRECTORY
    PCL::|(FAST-READER-METHOD DEFINITION-SOURCE-MIXIN SOURCE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SOURCE)| S::C-SET-FUNCTION-ENV
-   S::C-CONS-CDR PCL::FORMAT-STRING COMMON-LISP::NSTRING-DOWNCASE
-   S::C-PACKAGE-INTERNAL_FP S::*FCOMPLEX PCL::*MF2CP* PCL::ARGS-ENTRY
-   S::*DCOMPLEX S::C-PACKAGE-LINK PCL::MODULES PCL::KNOWN-TYPES
-   PCL::PAT PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SOURCE)|
+   CSTRUCT::C-SET-FUNCTION-ENV CSTRUCT::C-CONS-CDR PCL::FORMAT-STRING
+   COMMON-LISP::NSTRING-DOWNCASE CSTRUCT::C-PACKAGE-INTERNAL_FP
+   CSTRUCT::*FCOMPLEX PCL::*MF2CP* PCL::ARGS-ENTRY CSTRUCT::*DCOMPLEX
+   CSTRUCT::C-PACKAGE-LINK PCL::MODULES PCL::KNOWN-TYPES PCL::PAT
+   PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P
    PCL::CLASS-DEFSTRUCT-CONSTRUCTOR PCL::SLOT-ENTRY COMMON-LISP::PLUSP
    PCL::METHOD-ALIST PCL::POST-KEYWORD PCL::DFUN-INFO-FUNCTION
    PCL::COMPUTE-VALID-P COMMON-LISP::RANDOM PCL::DIRECT-METHODS
-   PCL::NO-EQL-SPECLS-P S::C-T-XX PCL::CHECK-INITARGS-1
+   PCL::NO-EQL-SPECLS-P CSTRUCT::C-T-XX PCL::CHECK-INITARGS-1
    PCL::SHORT-METHOD-COMBINATION PCL::CALL-ENTRY PCL::ADD
-   COMMON-LISP::MISMATCH S::C-ARRAY-ELTSIZE PCL::SLOT-READER-SYMBOL
+   COMMON-LISP::MISMATCH CSTRUCT::C-ARRAY-ELTSIZE
+   PCL::SLOT-READER-SYMBOL
    PCL::|(SETF GENERIC-FUNCTION-METHOD-COMBINATION)|
    PCL::COMPUTE-STD-CPL PCL::*EFFECTIVE-METHOD-TABLE*
    PCL::PV-TABLE-CALL-LIST
@@ -4622,20 +4659,21 @@
    PCL::PRINT-DFUN-INFO PCL::INITS PCL::BOUNDP-METHOD
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::DEF)|
    SYSTEM::DEFENTRY PCL::FGEN-GENERATOR PCL::NEW-PREVIOUS
-   PCL::LOCK-COUNT COMMON-LISP::READER-ERROR S::C-T-TT
+   PCL::LOCK-COUNT COMMON-LISP::READER-ERROR CSTRUCT::C-T-TT
    PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN PCL::DFUN-INFO-P PCL::MAKE-MODULE
    COMMON-LISP::ROOM COMMON-LISP::MULTIPLE-VALUE-LIST
    PCL::FILL-CACHE-FROM-CACHE-P PCL::MODULE-NAME
    PCL::*GET-WRAPPER-CACHE-NUMBER*
-   PCL::*GLOBAL-EFFECTIVE-METHOD-GENSYMS* S::C-T-ST PCL::MAKE-CAXR
-   COMMON-LISP::ARITHMETIC-ERROR-OPERANDS PCL::DFUN-COUNT PCL::CDC
-   PCL::INTO PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::INCLUDED)|
+   PCL::*GLOBAL-EFFECTIVE-METHOD-GENSYMS* CSTRUCT::C-T-ST
+   PCL::MAKE-CAXR COMMON-LISP::ARITHMETIC-ERROR-OPERANDS
+   PCL::DFUN-COUNT PCL::CDC PCL::INTO
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::INCLUDED)|
    SYSTEM::STRUCTURE-REF SYSTEM::STRUCTURE-DEF COMMON-LISP::CONS
    PCL::INST PCL::PARSE-GSPEC PCL::INITP COMMON-LISP::CONJUGATE
    PCL::ALLOCATE-STANDARD-INSTANCE--MACRO PCL::SPECIALIZERS-OR-METHOD
    PCL::INNER-DECLS PCL::MAKE-DEFAULT-METHOD-ONLY
    PCL::CAN-OPTIMIZE-ACCESS PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION
-   COMMON-LISP::HASH-TABLE S::C-T-TP PCL::EARLY-GF-SPEC
+   COMMON-LISP::HASH-TABLE CSTRUCT::C-T-TP PCL::EARLY-GF-SPEC
    PCL::|PCL::STANDARD-SLOT-DEFINITION class predicate|
    PCL::|PCL::STANDARD-DIRECT-SLOT-DEFINITION class predicate|
    PCL::|PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
@@ -4645,81 +4683,83 @@
    COMMON-LISP::RASSOC-IF
    PCL::|PCL::FAST-INSTANCE-BOUNDP class predicate|
    PCL::METHOD-NAME-DECLARATION PCL::EFFECTIVE COMMON-LISP::*FEATURES*
-   COMMON-LISP::ASH S::C-ARRAY-SELF PCL::EARLY-METHOD-SPECIALIZERS
-   COMMON-LISP::FORMAT COMMON-LISP::FLOAT-DIGITS PCL::LIST-DFUN
-   PCL::TIE-BREAKER SYSTEM::ARRAY-DIMS
-   PCL::|PCL::ARG-INFO class predicate| ITERATE::MINIMIZING
-   PCL::SHORT-METHOD-COMBINATION-SIMPLE-TYPEP-FN PCL::INITIAL-METHODS
-   PCL::MAKE-DFUN-INFO PCL::FILL-DFUN-CACHE SYSTEM::STRUCTUREP
-   COMMON-LISP::STRUCTURE PCL::|__si::MAKE-TWO-CLASS|
-   PCL::|__si::MAKE-ONE-CLASS| PCL::*MF2P* PCL::REQUIRED-CHECKS
-   ITERATE::MAXIMIZING PCL::CACHING-CACHE PCL::VAR PCL::LMF-OPTIONS
-   S::C-PACKAGE-EXTERNAL_FP PCL::INSURE-CACHING-DFUN PCL::OCLASS-SLOTS
-   PCL::CALLSREF PCL::*EARLY-P* S::C-PACKAGE-INTERNAL
-   COMMON-LISP::REDUCE PCL::DO-ONE-FILL-FROM-LINE S::C-ARRAY-DIM
-   PCL::COMPILE-PCL PCL::FAST-METHOD-CALL-ARG-INFO COMMON-LISP::LDB
+   COMMON-LISP::ASH CSTRUCT::C-ARRAY-SELF
+   PCL::EARLY-METHOD-SPECIALIZERS COMMON-LISP::FORMAT
+   COMMON-LISP::FLOAT-DIGITS PCL::LIST-DFUN PCL::TIE-BREAKER
+   SYSTEM::ARRAY-DIMS PCL::|PCL::ARG-INFO class predicate|
+   ITERATE::MINIMIZING PCL::SHORT-METHOD-COMBINATION-SIMPLE-TYPEP-FN
+   PCL::INITIAL-METHODS PCL::MAKE-DFUN-INFO PCL::FILL-DFUN-CACHE
+   SYSTEM::STRUCTUREP COMMON-LISP::STRUCTURE
+   PCL::|__si::MAKE-TWO-CLASS| PCL::|__si::MAKE-ONE-CLASS| PCL::*MF2P*
+   PCL::REQUIRED-CHECKS ITERATE::MAXIMIZING PCL::CACHING-CACHE PCL::VAR
+   PCL::LMF-OPTIONS CSTRUCT::C-PACKAGE-EXTERNAL_FP
+   PCL::INSURE-CACHING-DFUN PCL::OCLASS-SLOTS PCL::CALLSREF
+   PCL::*EARLY-P* CSTRUCT::C-PACKAGE-INTERNAL COMMON-LISP::REDUCE
+   PCL::DO-ONE-FILL-FROM-LINE CSTRUCT::C-ARRAY-DIM PCL::COMPILE-PCL
+   PCL::FAST-METHOD-CALL-ARG-INFO COMMON-LISP::LDB
    PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN PCL::OBJECT-PLIST
    COMMON-LISP::DECODE-FLOAT PCL::ACCESSORS
    COMMON-LISP::STRING-NOT-GREATERP
    PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE
    COMMON-LISP::PATHNAME-DIRECTORY PCL::|(SETF GENERIC-FUNCTION-NAME)|
    COMMON-LISP::CAR COMMON-LISP::UNION PCL::EARLY-METHOD-LAMBDA-LIST
-   PCL::XEROX-LOW S::C-CHARACTER-NAME PCL::WFT-TYPE1 PCL::PATTERNS
-   COMMON-LISP::COPY-READTABLE S::C-T-W PCL::GET-CPD
-   COMMON-LISP::VALUES-LIST PCL::NAMED-OBJECT-PRINT-FUNCTION
-   PCL::INITIAL-DFUN PCL::EQL-SPECIALIZER-P PCL::VALSYM
+   PCL::XEROX-LOW CSTRUCT::C-CHARACTER-NAME PCL::WFT-TYPE1
+   PCL::PATTERNS COMMON-LISP::COPY-READTABLE CSTRUCT::C-T-W
+   PCL::GET-CPD COMMON-LISP::VALUES-LIST
+   PCL::NAMED-OBJECT-PRINT-FUNCTION PCL::INITIAL-DFUN
+   PCL::EQL-SPECIALIZER-P PCL::VALSYM
    PCL::*DESCRIBE-METAOBJECTS-AS-OBJECTS-P* COMMON-LISP::GENTEMP
    COMMON-LISP::NREVERSE COMMON-LISP::LOGTEST
    PCL::CHANGE-CLASS-INTERNAL PCL::REQUIRED-ARGS PCL::OTHER-SLOTDS
-   S::C-T-T PCL::*LIST-TAILS COMMON-LISP::BIT-AND
+   CSTRUCT::C-T-T PCL::*LIST-TAILS COMMON-LISP::BIT-AND
    PCL::EARLY-METHOD-CLASS PCL::CLASS-METHOD PCL::MAKE-INITIAL
-   PCL::GENERA PCL::LAMBDA-LIST S::C-PACKAGE-NAME PCL::READER-FUNCTION
-   ITERATE::SUMMING PCL::OW1 PCL::CYCLE-REASONS PCL::CACHE-VECTOR-SIZE
-   COMMON-LISP::PATHNAME-HOST COMMON-LISP::SPACE
-   PCL::UPDATE-STD-OR-STR-METHODS S::C-SET-T-MELTTYPE
-   PCL::MAKE-DFUN-CALL S::C-T-PD PCL::LIST-EQ
+   PCL::GENERA PCL::LAMBDA-LIST CSTRUCT::C-PACKAGE-NAME
+   PCL::READER-FUNCTION ITERATE::SUMMING PCL::OW1 PCL::CYCLE-REASONS
+   PCL::CACHE-VECTOR-SIZE COMMON-LISP::PATHNAME-HOST COMMON-LISP::SPACE
+   PCL::UPDATE-STD-OR-STR-METHODS CSTRUCT::C-SET-T-MELTTYPE
+   PCL::MAKE-DFUN-CALL CSTRUCT::C-T-PD PCL::LIST-EQ
    COMMON-LISP::BROADCAST-STREAM-STREAMS
    PCL::*INVALIDATE-DISCRIMINATING-FUNCTION-FORCE-P*
    COMMON-LISP::LDB-TEST PCL::PKG-LIST PCL::WRITERS-INIT
-   S::C-HASHTABLE-PAD5 COMMON-LISP::GET-SETF-EXPANSION
-   COMMON-LISP::SUBSTITUTE-IF S::C-T-MF S::C-SET-PATHNAME-HOST
-   PCL::COMPUTE-CODE SYSTEM::~ PCL::FAST-METHOD-CALL
-   PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL PCL::FAST-METHOD-CALL-PV-CELL
-   SYSTEM::|\|| PCL::+PCL+ PCL::GENSYMS PCL::DIRECT-SLOTS-P
-   PCL::COLLECT-GFS PCL::NEW-STATE PCL::NEW-SPECIALIZER
-   COMMON-LISP::END-OF-FILE PCL::CANONICAL S::C-T-M
-   COMMON-LISP::VECTOR-PUSH-EXTEND PCL::|ACCESSOR-DFUN-INFO SLOT1|
-   PCL::*INVALID-DFUNS-ON-STACK* S::C-ARRAY-ELTMODE
-   PCL::MAKE-METHOD-CALL PCL::|PCL::PV-TABLE class predicate|
-   PCL::%CCLOSURE-ENV COMMON-LISP::LOGNAND COMMON-LISP::TYPECASE
-   S::C-HASHTABLE-PAD4 PCL::GET-PV-CELL-FOR-CLASS PCL::*UMI-GFS*
-   PCL::LOAD-DEFGENERIC COMMON-LISP::SIMPLE-STRING-P
-   COMMON-LISP::SIMPLE-STRING COMMON-LISP::SUBSTITUTE-IF-NOT
-   COMMON-LISP::RASSOC COMMON-LISP::CAAR S::C-PACKAGE-EXTERNAL
-   PCL::MODULE PCL::OW0 PCL::W0 SYSTEM::^ PCL::LIST-ALL-DFUNS
-   PCL::CALL-INITIALIZE-FUNCTION PCL::FIND-SLOT-DEFINITION
-   COMMON-LISP::PARSE-NAMESTRING PCL::MP
+   CSTRUCT::C-HASHTABLE-PAD5 COMMON-LISP::GET-SETF-EXPANSION
+   COMMON-LISP::SUBSTITUTE-IF CSTRUCT::C-T-MF
+   CSTRUCT::C-SET-PATHNAME-HOST PCL::COMPUTE-CODE SYSTEM::~
+   PCL::FAST-METHOD-CALL PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
+   PCL::FAST-METHOD-CALL-PV-CELL SYSTEM::|\|| PCL::+PCL+ PCL::GENSYMS
+   PCL::DIRECT-SLOTS-P PCL::COLLECT-GFS PCL::NEW-STATE
+   PCL::NEW-SPECIALIZER COMMON-LISP::END-OF-FILE PCL::CANONICAL
+   CSTRUCT::C-T-M COMMON-LISP::VECTOR-PUSH-EXTEND
+   PCL::|ACCESSOR-DFUN-INFO SLOT1| PCL::*INVALID-DFUNS-ON-STACK*
+   CSTRUCT::C-ARRAY-ELTMODE PCL::MAKE-METHOD-CALL
+   PCL::|PCL::PV-TABLE class predicate| PCL::%CCLOSURE-ENV
+   COMMON-LISP::LOGNAND COMMON-LISP::TYPECASE CSTRUCT::C-HASHTABLE-PAD4
+   PCL::GET-PV-CELL-FOR-CLASS PCL::*UMI-GFS* PCL::LOAD-DEFGENERIC
+   COMMON-LISP::SIMPLE-STRING-P COMMON-LISP::SIMPLE-STRING
+   COMMON-LISP::SUBSTITUTE-IF-NOT COMMON-LISP::RASSOC COMMON-LISP::CAAR
+   CSTRUCT::C-PACKAGE-EXTERNAL PCL::MODULE PCL::OW0 PCL::W0 SYSTEM::^
+   PCL::LIST-ALL-DFUNS PCL::CALL-INITIALIZE-FUNCTION
+   PCL::FIND-SLOT-DEFINITION COMMON-LISP::PARSE-NAMESTRING PCL::MP
    COMMON-LISP::*MACROEXPAND-HOOK* COMMON-LISP::MAP PCL::ALLOCATE-MACRO
    PCL::|__si::MAKE-NO-METHODS|
    PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| PCL::Y
-   COMMON-LISP::COND PCL::X S::C-T-FF PCL::W PCL::USE PCL::CPL2
+   COMMON-LISP::COND PCL::X CSTRUCT::C-T-FF PCL::W PCL::USE PCL::CPL2
    COMMON-LISP::SIMPLE-WARNING PCL::V PCL::INSTANCE-SLOTS-LAYOUT
-   S::C-HASHTABLE-PAD3 S::C-SET-FUNCTION-NEVAL COMMON-LISP::T S::C-T-H
-   PCL::S PCL::INSTANCE-ESLOTDS PCL::R PCL::REMOVE-READER-METHOD
-   PCL::GF-NOPT COMMON-LISP::DESCRIBE PCL::Q PCL::P
-   PCL::*WRAPPER-OF-COST* PCL::SUB-TESTS PCL::SET-FUNCTION-NAME
+   CSTRUCT::C-HASHTABLE-PAD3 CSTRUCT::C-SET-FUNCTION-NEVAL
+   COMMON-LISP::T CSTRUCT::C-T-H PCL::S PCL::INSTANCE-ESLOTDS PCL::R
+   PCL::REMOVE-READER-METHOD PCL::GF-NOPT COMMON-LISP::DESCRIBE PCL::Q
+   PCL::P PCL::*WRAPPER-OF-COST* PCL::SUB-TESTS PCL::SET-FUNCTION-NAME
    PCL::FUNCALLABLE-STANDARD-OBJECT PCL::O PCL::N PCL::CPL1
    COMMON-LISP::RETURN-FROM PCL::M PCL::L PCL::COMPILE-LAMBDA PCL::K
    PCL::FORM-LIST-TO-LISP PCL::J PCL::I COMMON-LISP::CTYPECASE
-   COMMON-LISP::ETYPECASE S::C-T-F PCL::G PCL::F
-   PCL::FUNCALLABLE-STANDARD-CLASS-WRAPPER S::C-SET-FUNCTION-SELF
+   COMMON-LISP::ETYPECASE CSTRUCT::C-T-F PCL::G PCL::F
+   PCL::FUNCALLABLE-STANDARD-CLASS-WRAPPER CSTRUCT::C-SET-FUNCTION-SELF
    PCL::E PCL::D PCL::C PCL::WALKED-LAMBDA-BODY PCL::B
-   COMMON-LISP::SOME S::C-T-E PCL::A COMMON-LISP::LABELS PCL::OBJ
-   COMMON-LISP::> S::C-HASHTABLE-PAD2 COMMON-LISP::= COMMON-LISP::<
-   PCL::EARLY-NAME PCL::BINDINGS PCL::IDENTITY-WITH-ONE-ARG
-   PCL::LINE-RESERVED-P PCL::HOME
+   COMMON-LISP::SOME CSTRUCT::C-T-E PCL::A COMMON-LISP::LABELS PCL::OBJ
+   COMMON-LISP::> CSTRUCT::C-HASHTABLE-PAD2 COMMON-LISP::=
+   COMMON-LISP::< PCL::EARLY-NAME PCL::BINDINGS
+   PCL::IDENTITY-WITH-ONE-ARG PCL::LINE-RESERVED-P PCL::HOME
    PCL::FUNCALLABLE-INSTANCE-DATA-POSITION
-   PCL::CACHED-MAKE-INSTANCE-FUNCTION S::C-SYMBOL-PLIST
+   PCL::CACHED-MAKE-INSTANCE-FUNCTION CSTRUCT::C-SYMBOL-PLIST
    PCL::MAKE-INITIAL-DFUN PCL::COMMON COMMON-LISP::SHADOW
    PCL::POSS-APPL COMMON-LISP::/ PCL::EARLY-METHOD-FUNCTION
    COMMON-LISP::- PCL::SHORT-COMBINATION-IDENTITY-WITH-ONE-ARGUMENT
@@ -4729,8 +4769,8 @@
    COMMON-LISP::* PCL::BUILT-IN-OR-STRUCTURE-WRAPPER
    PCL::METHOD-FUNCTION-PLIST
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::OFFSET)| SYSTEM::&
-   S::C-HASHTABLE-PAD1 S::% COMMON-LISP::DELETE PCL::*MF1CP*
-   PCL::NON-SETF-VAR PCL::FALSE-VALUE
+   CSTRUCT::C-HASHTABLE-PAD1 CSTRUCT::% COMMON-LISP::DELETE
+   PCL::*MF1CP* PCL::NON-SETF-VAR PCL::FALSE-VALUE
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
    COMMON-LISP::PATHNAMEP COMMON-LISP::SET-DIFFERENCE PCL::SLOTS
@@ -4760,11 +4800,11 @@
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::CONSTRUCTORS)|
    COMMON-LISP::OPEN
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::NO-EMIT)|
-   COMMON-LISP::DISASSEMBLE S::C-OCOMPLEX-REAL PCL::WRAPPER-2
+   COMMON-LISP::DISASSEMBLE CSTRUCT::C-OCOMPLEX-REAL PCL::WRAPPER-2
    PCL::GET-CACHE-VECTOR-LOCK-COUNT PCL::GET-SLOTS PCL::NEW-SLOTS
    PCL::|FAST-INSTANCE-BOUNDP SLOT0| COMMON-LISP::CONTINUE
-   COMMON-LISP::TAN S::C-SET-HASHTABLE-RHSIZE S::C-SET-HASHTABLE-SIZE
-   PCL::WRAPPER-0 PCL::||)
+   COMMON-LISP::TAN CSTRUCT::C-SET-HASHTABLE-RHSIZE
+   CSTRUCT::C-SET-HASHTABLE-SIZE PCL::WRAPPER-0 PCL::||)
  "PCL")
 
 (lisp::in-package "SI")
--- gcl27-2.7.0.orig/pcl/sys-proclaim.lisp
+++ gcl27-2.7.0/pcl/sys-proclaim.lisp
@@ -1,246 +1,832 @@
 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
-   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-DEFAULT-ONLY)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ACCESSOR-DFUN-INFO)) (T))
-   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE)) 
+   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (T))
+   PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE
+   PCL::GF-INFO-C-A-M-EMF-STD-P PCL::ARG-INFO-LAMBDA-LIST
+   PCL::GF-INFO-FAST-MF-P PCL::GF-INFO-STATIC-C-A-M-EMF
+   PCL::ARG-INFO-NUMBER-OPTIONAL PCL::ARG-INFO-METATYPES
+   PCL::ARG-INFO-KEYWORDS PCL::ARG-INFO-PRECEDENCE
+   PCL::ARG-INFO-KEY/REST-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (INTEGER 0 9223372036854775807))
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::PARSE-QUALIFIER-PATTERN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR
+      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
+     (T)
+     (OR
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM)))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T))
-    (OR
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MUTATE-SLOTS-AND-CALLS PCL::SLOT-NAME-LISTS-FROM-SLOTS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-AND)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (NULL) (T)) (T))
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (SYSTEM:PROPER-CONS (T) (T))
      (OR
       (OR
-       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-       (SIMPLE-ARRAY BIT (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-       (SIMPLE-ARRAY SHORT-FLOAT (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-       (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
+   PCL::DESTRUCTURE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (T)) SETF::|PCL::INITIALIZE-INFO SLOT5|
+   SETF::|PCL::SYSTEM:S-DATA SLOT3| SETF::|PCL::GDEFINITION|
+   SETF::|PCL::ONE-INDEX-DFUN-INFO SLOT2| SETF::|PCL::ARG-INFO SLOT5|
+   SETF::|PCL::FAST-METHOD-CALL SLOT2|
+   SETF::|PCL::CLASS-DEFSTRUCT-CONSTRUCTOR| SETF::|PCL::PV-TABLE SLOT1|
+   SETF::|PCL::MODULE SLOT2| SETF::|PCL::CACHE SLOT7|
+   SETF::|PCL::COMPILER::FN SLOT2| SETF::|PCL::SYSTEM:S-DATA SLOT13|
+   SETF::|PCL::SLOT-DEFINITION-LOCATION|
+   SETF::|PCL::SLOT-DEFINITION-READER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-WRITER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-BOUNDP-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-ALLOCATION|
+   SETF::|PCL::SLOT-DEFINITION-INITFUNCTION|
+   SETF::|PCL::INITIALIZE-INFO SLOT3| SETF::|PCL::SYSTEM:S-DATA SLOT1|
+   SETF::|PCL::GF-PRETTY-ARGLIST| SETF::|PCL::ARG-INFO SLOT3|
+   SETF::|PCL::FAST-METHOD-CALL SLOT0|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT3|
+   SETF::|PCL::INITIALIZE-INFO SLOT13| SETF::|PCL::MODULE SLOT0|
+   SETF::|PCL::CACHE SLOT5| SETF::|PCL::COMPILER::FN SLOT0|
+   SETF::|PCL::SYSTEM:S-DATA SLOT11|
+   SETF::|PCL::SLOT-DEFINITION-INITFORM|
+   SETF::|PCL::INITIALIZE-INFO SLOT1| SETF::|PCL::ARG-INFO SLOT1|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT1|
+   SETF::|PCL::OBJECT-PLIST| SETF::|PCL::SYSTEM:S-DATA SLOT8|
+   SETF::|PCL::INITIALIZE-INFO SLOT11| SETF::|PCL::CACHE SLOT3|
+   SETF::|PCL::GENERIC-FUNCTION-METHOD-CLASS|
+   SETF::|PCL::ACCESSOR-DFUN-INFO SLOT1|
+   SETF::|PCL::FIND-CLASS-PREDICATE| SETF::|PCL::GENERIC-FUNCTION-NAME|
+   SETF::|PCL::COMPILER::FN SLOT7| SETF::|PCL::METHOD-CALL SLOT1|
+   SETF::|PCL::FAST-INSTANCE-BOUNDP SLOT0|
+   SETF::|PCL::INITIALIZE-INFO SLOT8| SETF::|PCL::SYSTEM:S-DATA SLOT6|
+   SETF::|PCL::CACHE SLOT1| SETF::|PCL::ARG-INFO SLOT8|
+   SETF::|PCL::SLOT-DEFINITION-TYPE|
+   SETF::|PCL::SLOT-DEFINITION-READERS|
+   SETF::|PCL::SLOT-DEFINITION-WRITERS|
+   SETF::|PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL|
+   SETF::|PCL::COMPILER::FN SLOT5| SETF::|PCL::SYSTEM:S-DATA SLOT16|
+   SETF::|PCL::CACHE SLOT11| SETF::|PCL::CHECKING SLOT1|
+   SETF::|PCL::INITIALIZE-INFO SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT4|
+   SETF::|PCL::ARG-INFO SLOT6| SETF::|PCL::FAST-METHOD-CALL SLOT3|
+   SETF::|PCL::PV-TABLE SLOT2| SETF::|PCL::MODULE SLOT3|
+   SETF::|PCL::CACHE SLOT8| SETF::|PCL::COMPILER::FN SLOT3|
+   SETF::|PCL::SYSTEM:S-DATA SLOT14| SETF::|PCL::INITIALIZE-INFO SLOT4|
+   SETF::|PCL::SYSTEM:S-DATA SLOT2| SETF::|PCL::TWO-CLASS SLOT4|
+   SETF::|PCL::CLASS-DIRECT-SLOTS| SETF::|PCL::CLASS-SLOTS|
+   SETF::|PCL::ONE-CLASS SLOT3| SETF::|PCL::METHOD-GENERIC-FUNCTION|
+   SETF::|PCL::ARG-INFO SLOT4| SETF::|PCL::FAST-METHOD-CALL SLOT1|
+   SETF::|COMMON-LISP::CLASS-NAME|
+   SETF::|PCL::GENERIC-FUNCTION-METHOD-COMBINATION|
+   SETF::|PCL::PV-TABLE SLOT0| SETF::|PCL::MODULE SLOT1|
+   SETF::|PCL::CACHE SLOT6| SETF::|PCL::COMPILER::FN SLOT1|
+   SETF::|PCL::SYSTEM:S-DATA SLOT12| SETF::|PCL::CLASS-DEFSTRUCT-FORM|
+   SETF::|PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST|
+   SETF::|PCL::INITIALIZE-INFO SLOT2|
+   SETF::|PCL::SLOT-DEFINITION-INITARGS|
+   SETF::|PCL::SYSTEM:S-DATA SLOT0| SETF::|PCL::ARG-INFO SLOT2|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT2|
+   SETF::|PCL::SYSTEM:S-DATA SLOT9| SETF::|PCL::INITIALIZE-INFO SLOT12|
+   SETF::|PCL::CACHE SLOT4| SETF::|PCL::METHOD-FUNCTION-PLIST|
+   SETF::|PCL::SYSTEM:S-DATA SLOT10| SETF::|PCL::INITIALIZE-INFO SLOT0|
+   SETF::|PCL::SLOT-DEFINITION-CLASS| SETF::|PCL::COMPILER::FN SLOT8|
+   SETF::|PCL::ARG-INFO SLOT0| SETF::|PCL::SLOT-DEFINITION-NAME|
+   SETF::|PCL::INITIALIZE-INFO SLOT9|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT0|
+   SETF::|PCL::SYSTEM:S-DATA SLOT7| SETF::|PCL::INITIALIZE-INFO SLOT10|
+   SETF::|PCL::CACHE SLOT2| SETF::|PCL::ARG-INFO SLOT9|
+   SETF::|PCL::ARG-INFO SLOT10|
+   SETF::|PCL::GENERIC-FUNCTION-INITIAL-METHODS|
+   SETF::|PCL::GENERIC-FUNCTION-METHODS|
+   SETF::|PCL::COMPILER::FN SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT17|
+   SETF::|PCL::METHOD-CALL SLOT0| SETF::|PCL::INITIALIZE-INFO SLOT7|
+   SETF::|PCL::SYSTEM:S-DATA SLOT5| SETF::|PCL::CACHE SLOT0|
+   SETF::|PCL::ARG-INFO SLOT7| SETF::|PCL::CLASS-INITIALIZE-INFO|
+   SETF::|PCL::GF-DFUN-STATE| SETF::|PCL::PV-TABLE SLOT3|
+   SETF::|PCL::MODULE SLOT4| SETF::|PCL::CACHE SLOT9|
+   SETF::|PCL::COMPILER::FN SLOT4| SETF::|PCL::SYSTEM:S-DATA SLOT15|
+   SETF::|PCL::CACHE SLOT10| SETF::|PCL::DFUN-INFO SLOT0|
+   WALKER::ENVIRONMENT-FUNCTION WALKER::ENVIRONMENT-MACRO
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot WRITER| 
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot WRITER|
+   ITERATE::MV-SETQ SLOT-BOUNDP
+   PCL:FUNCALLABLE-STANDARD-INSTANCE-ACCESS SLOT-MAKUNBOUND
+   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::VARIABLE-CLASS
+   PCL::COMPUTE-APPLICABLE-KEYWORDS PCL::COMPUTE-CONSTANTS
+   PCL::FDEFINE-CAREFULLY PCL::SET-INITIAL-METHODS
+   PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P PCL::PROCLAIM-DEFMETHOD
+   PCL::DESCRIBE-PACKAGE PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER
+   PCL::%CCLOSURE-ENV-NTHCDR PCL::MAP-PV-TABLE-REFERENCES-OF
+   PCL::AUGMENT-TYPE PCL::GET-KEY-ARG-TAIL PCL::VALUE-FOR-CACHING
+   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::REAL-REMOVE-METHOD
+   PCL::SET-METHODS PCL::SET-STRUCTURE-SVUC-METHOD PCL::COMPUTE-PV
+   PCL::SWAP-WRAPPERS-AND-SLOTS PCL::REDIRECT-EARLY-FUNCTION-INTERNAL
+   WALKER:VARIABLE-SPECIAL-P PCL::LEGAL-LAMBDA-LIST-P
+   PCL::FIND-STANDARD-II-METHOD PCL::SLOT-BOUNDP-NORMAL
+   PCL::SET-STANDARD-SVUC-METHOD PCL::PROCLAIM-DEFGENERIC
+   PCL::SET-WRAPPER PCL::ADD-FORMS PCL::MAKE-CLASS-PREDICATE
+   PCL::UPDATE-INITS PCL::REDEFINE-FUNCTION
+   PCL::SET-FUNCTION-PRETTY-ARGLIST PCL::PRINTING-RANDOM-THING-INTERNAL
+   PCL::SLOT-UNBOUND-INTERNAL PCL::PLIST-VALUE PCL::MAKE-CDXR
+   PCL::FIND-SLOT-DEFINITION PCL::SET-FUNCTION-NAME)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (OR
       (OR
-       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::FIND-SUPERCLASS-CHAIN)) 
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (INTEGER -9223372036854775807 9223372036854775807)))
+   PCL::COMPUTE-STD-CPL-PHASE-1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
+   (FUNCTION
+    ((T) (T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   WALKER::NOTE-DECLARATION WALKER::NOTE-LEXICAL-BINDING
+   PCL::MAKE-STD-WRITER-METHOD-FUNCTION
+   PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION
+   PCL::MAKE-STD-READER-METHOD-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
+   (FUNCTION
+    ((T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::LIST-DFUN)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (NOT (MEMBER NIL))) PCL::PV-TABLE-LOOKUP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
-   ITERATE::OPTIMIZE-ITERATE-FORM ITERATE::SIMPLE-EXPAND-GATHERING-FORM
-   ITERATE::RENAME-AND-CAPTURE-VARIABLES PCL::MAKE-METHOD-SPEC
-   PCL::EXPAND-DEFGENERIC PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
-   PCL::FIRST-FORM-TO-LISP PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
-   PCL::EMIT-BOUNDP-CHECK PCL::MAKE-TOP-LEVEL-FORM
-   PCL::EMIT-SLOT-READ-FORM PCL::EMIT-1-T-DLAP PCL::MAKE-DFUN-CALL)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
+   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::ARG-INFO)) PCL::MAKE-ARG-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (T))
-   PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
-   PCL::LOAD-DEFCLASS PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION
-   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-   PCL::REAL-LOAD-DEFCLASS)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES &OPTIONAL (T) (T) (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
+   PCL::CACHE-MISS-VALUES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (VALUES &REST T))
-   WALKER::WALK-TEMPLATE-HANDLE-REPEAT PCL::WALK-METHOD-LAMBDA
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
-   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
-   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
-   PCL::MAKE-METHOD-INITARGS-FORM
-   PCL::|(FAST-METHOD NO-NEXT-METHOD (STANDARD-GENERIC-FUNCTION STANDARD-METHOD))|
-   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|)) 
+   (FUNCTION
+    ((T) (INTEGER 0 9223372036854775807) &REST T)
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE-FROM-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
-   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|)) 
+   (FUNCTION ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::CPD-COUNT)) 
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (OR
+       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)
+       (STRUCTURE PCL::CHECKING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
+       (STRUCTURE PCL::NO-METHODS))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-DFUN-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::COPY-CONSTANT-VALUE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (VALUES &REST T))
+   SETF::|PCL::GENERIC-FUNCTION-DECLARATIONS|
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OWNER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER DEF slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER DEF slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INDEX slot READER|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INDEX slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot READER|
+   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL FIELD slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NAME slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL FIELD slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL NLINES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL NLINES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NKEYS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL VALUEP slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NKEYS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL VALUEP slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL KEY slot READER|
+   SLOT-ACCESSOR-NAME::|PCL KEY slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PORT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PORT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL READERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL MASK slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL MASK slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OWNER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot READER| NO-APPLICABLE-METHOD
+   PCL:UPDATE-DEPENDENT SLOT-MISSING SLOT-UNBOUND
+   PCL:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER INVALID-METHOD-ERROR
+   METHOD-COMBINATION-ERROR PCL::REMOVE-NAMED-METHOD
+   PCL::|PCL::TRACED-METHOD class predicate| PCL::USE-PACKAGE-PCL
+   PCL::|COMMON-LISP::NULL class predicate|
+   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
+   PCL::|COMMON-LISP::SYMBOL class predicate|
+   PCL::|COMMON-LISP::CHARACTER class predicate|
+   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
+   PCL::|COMMON-LISP::STRING class predicate|
+   PCL::|COMMON-LISP::VECTOR class predicate|
+   PCL::|COMMON-LISP::ARRAY class predicate|
+   PCL::|COMMON-LISP::STREAM class predicate|
+   PCL::|COMMON-LISP::FILE-STREAM class predicate|
+   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
+   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
+   PCL::|COMMON-LISP::STRING-STREAM class predicate|
+   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
+   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
+   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
+   PCL::|COMMON-LISP::HASH-TABLE class predicate|
+   PCL::|COMMON-LISP::PACKAGE class predicate|
+   PCL::|COMMON-LISP::READTABLE class predicate|
+   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
+   PCL::|COMMON-LISP::PATHNAME class predicate|
+   PCL::|COMMON-LISP::CONS class predicate|
+   PCL::|COMMON-LISP::LIST class predicate|
+   PCL::|COMMON-LISP::SEQUENCE class predicate|
+   PCL::|COMMON-LISP::RATIO class predicate|
+   PCL::|COMMON-LISP::INTEGER class predicate|
+   PCL::|COMMON-LISP::RATIONAL class predicate|
+   PCL::|COMMON-LISP::REAL class predicate|
+   PCL::|COMMON-LISP::FLOAT class predicate|
+   PCL::|COMMON-LISP::COMPLEX class predicate|
+   PCL::|COMMON-LISP::NUMBER class predicate|
+   PCL::|COMMON-LISP::T class predicate|
+   PCL::|COMMON-LISP::FUNCTION class predicate|
+   PCL::|COMMON-LISP::STRUCTURE-OBJECT class predicate|
+   PCL::|COMMON-LISP::STANDARD-OBJECT class predicate|
+   PCL::|COMMON-LISP::BUILT-IN-CLASS class predicate|
+   PCL::|PCL::SPECIALIZER-WITH-OBJECT class predicate|
+   PCL::|PCL::MODULE class predicate|
+   PCL::|PCL::ONE-INDEX-DFUN-INFO class predicate|
+   PCL::|PCL::DOCUMENTATION-MIXIN class predicate|
+   PCL::|PCL::ONE-CLASS class predicate|
+   PCL::|PCL::SLOT-OBJECT class predicate|
+   PCL::|PCL::INITIALIZE-INFO class predicate|
+   PCL::|PCL::CACHE class predicate|
+   PCL::|PCL::SLOT-DEFINITION class predicate|
+   PCL::|PCL::DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|SYSTEM::S-DATA class predicate|
+   PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE
+   PCL::|PCL::PLIST-MIXIN class predicate|
+   PCL::|PCL::CLASS-PRECEDENCE-DESCRIPTION class predicate|
+   PCL::|PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate|
+   PCL::|PCL::TWO-CLASS class predicate|
+   PCL::|PCL::CHECKING class predicate|
+   PCL::|PCL::DFUN-INFO class predicate|
+   PCL::|COMPILER::FN class predicate|
+   PCL::|PCL::EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::FUNCALLABLE-STANDARD-OBJECT class predicate|
+   PCL::|PCL::METHOD-CALL class predicate|
+   PCL::|PCL::METAOBJECT class predicate|
+   PCL::|PCL::DEPENDENT-UPDATE-MIXIN class predicate|
+   PCL::|PCL::DEFINITION-SOURCE-MIXIN class predicate|
+   PCL::ARG-INFO-READER PCL::UPDATE-CONSTRUCTORS
+   PCL::|PCL::STD-CLASS class predicate|
+   PCL::|PCL::PCL-CLASS class predicate|
+   PCL::|PCL::ACCESSOR-DFUN-INFO class predicate|
+   PCL::COMPATIBLE-META-CLASS-CHANGE-P
+   PCL::|PCL::FAST-METHOD-CALL class predicate|
+   PCL::|PCL::STANDARD-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-METHOD-COMBINATION class predicate|
+   PCL::|PCL::FAST-INSTANCE-BOUNDP class predicate|
+   PCL::|PCL::ARG-INFO class predicate|
+   PCL::|PCL::PV-TABLE class predicate|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MEMF-CODE-CONVERTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::KEY-NAMES)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 7)) PCL::CACHE-FIELD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
-   PCL::CACHE-NKEYS)) 
+   (FUNCTION ((T) (T) (T) (T)) (T)) WALKER::WALK-PROG/PROG*
+   WALKER::WALK-DO/DO* WALKER::WALK-LET/LET* PCL::BOOTSTRAP-SET-SLOT
+   PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
+   PCL::GET-WRAPPERS-FROM-CLASSES PCL::FROB-COMBINED-METHOD-ARGS
+   PCL::LOAD-LONG-DEFCOMBIN PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::MEMF-TEST-CONVERTER
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE PCL::OPTIMIZE-WRITER
+   PCL::OPTIMIZE-READER PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
+   PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|
+   PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
+   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
+   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+   PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
+   PCL::LOAD-SHORT-DEFCOMBIN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::CACHE-VALUEP)) 
+   (FUNCTION
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::CPD-COUNT)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES &REST T)) MAKE-INSTANCES-OBSOLETE
-   METHOD-QUALIFIERS PCL:METHOD-LAMBDA-LIST FUNCTION-KEYWORDS
-   PCL:SPECIALIZER-DIRECT-METHODS PCL:METHOD-SPECIALIZERS
-   PCL:SLOT-DEFINITION-ALLOCATION PCL:COMPUTE-CLASS-PRECEDENCE-LIST
-   PCL:CLASS-FINALIZED-P PCL:COMPUTE-DISCRIMINATING-FUNCTION
-   PCL:CLASS-DEFAULT-INITARGS PCL:CLASS-DIRECT-SLOTS
-   PCL:GENERIC-FUNCTION-LAMBDA-LIST PCL:FINALIZE-INHERITANCE
-   PCL:COMPUTE-SLOTS PCL:CLASS-SLOTS PCL:METHOD-FUNCTION
-   PCL:CLASS-PROTOTYPE PCL:CLASS-DIRECT-DEFAULT-INITARGS
-   PCL::INTERN-FUNCTION-NAME PCL::COMPILE-IIS-FUNCTIONS
-   PCL::|ARG-INFO SLOT10| PCL::MAKE-KEYWORD PCL::|PV-TABLE SLOT3|
-   PCL::|CHECKING SLOT1| PCL::|PV-TABLE SLOT2| PCL::SLOT-WRITER-SYMBOL
-   PCL::|PV-TABLE SLOT1|
-   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO
-   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::|PV-TABLE SLOT0|
-   PCL::|DFUN-INFO SLOT0|
-   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
-   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
-   PCL::|SYSTEM:S-DATA SLOT9| PCL::|SYSTEM:S-DATA SLOT8|
-   PCL::|SYSTEM:S-DATA SLOT7| PCL::|SYSTEM:S-DATA SLOT6|
-   PCL::|SYSTEM:S-DATA SLOT5| PCL::|SYSTEM:S-DATA SLOT4|
-   PCL::|SYSTEM:S-DATA SLOT3| PCL::COMPUTE-DEFAULT-INITARGS
-   PCL::|SYSTEM:S-DATA SLOT2| PCL::|SYSTEM:S-DATA SLOT1|
-   PCL::|SYSTEM:S-DATA SLOT0| PCL::DFUN-ARG-SYMBOL
-   PCL::CLASS-SLOT-CELLS PCL::SLOT-BOUNDP-SYMBOL
-   PCL::|METHOD-CALL SLOT1| PCL::|METHOD-CALL SLOT0|
-   PCL::GF-FAST-METHOD-FUNCTION-P PCL::|INITIALIZE-INFO SLOT9|
-   PCL::|INITIALIZE-INFO SLOT8| PCL::|INITIALIZE-INFO SLOT7|
-   PCL::|INITIALIZE-INFO SLOT6| PCL::|INITIALIZE-INFO SLOT5|
-   PCL::|INITIALIZE-INFO SLOT4| PCL::|INITIALIZE-INFO SLOT3|
-   PCL::|INITIALIZE-INFO SLOT2| PCL::|INITIALIZE-INFO SLOT1|
-   PCL::|INITIALIZE-INFO SLOT0| PCL::|CACHE SLOT11| PCL::|CACHE SLOT10|
-   PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::MAKE-CLASS-PREDICATE-NAME
-   PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS PCL::CLASS-CONSTRUCTORS
-   PCL::|ARG-INFO SLOT9| PCL::|ARG-INFO SLOT8| PCL::|ARG-INFO SLOT7|
-   PCL::|ARG-INFO SLOT6| PCL::|ARG-INFO SLOT5| PCL::|ARG-INFO SLOT4|
-   PCL::|COMPILER::FN SLOT8| PCL::|ARG-INFO SLOT3|
-   PCL::SPECIALIZER-METHOD-TABLE PCL::|COMPILER::FN SLOT7|
-   PCL::|ARG-INFO SLOT2| PCL::|COMPILER::FN SLOT6|
-   PCL::|ARG-INFO SLOT1| PCL::|COMPILER::FN SLOT5|
-   PCL::|ARG-INFO SLOT0| PCL::|COMPILER::FN SLOT4|
-   PCL::|COMPILER::FN SLOT3| PCL::|COMPILER::FN SLOT2|
-   PCL::|COMPILER::FN SLOT1| PCL::|COMPILER::FN SLOT0|
-   PCL::|TYPE-PREDICATE COMMON-LISP STRUCTURE-CLASS|
-   PCL::|TYPE-PREDICATE COMMON-LISP BUILT-IN-CLASS|
-   PCL::|TYPE-PREDICATE PCL FORWARD-REFERENCED-CLASS|
-   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-CLASS|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-CLASS|
-   PCL::|TYPE-PREDICATE PCL STD-CLASS|
-   PCL::|TYPE-PREDICATE PCL SLOT-CLASS|
-   PCL::|TYPE-PREDICATE PCL PCL-CLASS|
-   PCL::|TYPE-PREDICATE COMMON-LISP CLASS|
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER-WITH-OBJECT|
-   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-OBJECT|
-   PCL::|TYPE-PREDICATE PCL METAOBJECT|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-OBJECT|
-   PCL::|TYPE-PREDICATE PCL SHORT-METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE PCL LONG-METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE COMMON-LISP METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-GENERIC-FUNCTION|
-   PCL::|TYPE-PREDICATE COMMON-LISP GENERIC-FUNCTION|
-   PCL::|TYPE-PREDICATE PCL STRUCTURE-EFFECTIVE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STRUCTURE-DIRECT-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-EFFECTIVE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-DIRECT-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL EFFECTIVE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL DIRECT-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STRUCTURE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL SLOT-DEFINITION| PCL::GET-DISPATCH-FUNCTION
-   PCL::|FAST-METHOD-CALL SLOT3| PCL::|FAST-METHOD-CALL SLOT2|
-   PCL::INITIALIZE-INTERNAL-SLOT-FUNCTIONS
-   PCL::|FAST-METHOD-CALL SLOT1| PCL::GF-LAMBDA-LIST
-   PCL::|FAST-METHOD-CALL SLOT0| PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
-   PCL::|TYPE-PREDICATE PCL TRACED-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-BOUNDP-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-WRITER-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-READER-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-ACCESSOR-METHOD|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-METHOD|
-   PCL::|TYPE-PREDICATE COMMON-LISP METHOD| PCL::|SYSTEM:S-DATA SLOT17|
-   PCL::|SYSTEM:S-DATA SLOT16| PCL::|SYSTEM:S-DATA SLOT15|
-   PCL::|SYSTEM:S-DATA SLOT14| PCL::|SYSTEM:S-DATA SLOT13|
-   PCL::|SYSTEM:S-DATA SLOT12| PCL::|SYSTEM:S-DATA SLOT11|
-   PCL::|SYSTEM:S-DATA SLOT10| PCL::|ONE-INDEX-DFUN-INFO SLOT2|
-   PCL::CLASS-PREDICATE-NAME PCL::|TWO-CLASS SLOT4| PCL::|CACHE SLOT9|
-   PCL::GENERIC-FUNCTION-PRETTY-ARGLIST PCL::|CACHE SLOT8|
-   PCL::|CACHE SLOT7| PCL::|CACHE SLOT6| PCL::|CACHE SLOT5|
-   PCL::|CACHE SLOT4| PCL::|CACHE SLOT3| PCL::ACCESSOR-METHOD-CLASS
-   PCL::|CACHE SLOT2| PCL::|CACHE SLOT1| PCL::|CACHE SLOT0|
-   PCL::|ONE-CLASS SLOT3| PCL::METHOD-PRETTY-ARGLIST
-   PCL::|INITIALIZE-INFO SLOT13| PCL::KEYWORD-SPEC-NAME
-   PCL::|INITIALIZE-INFO SLOT12|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT3|
-   PCL::|INITIALIZE-INFO SLOT11|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT2|
-   PCL::|INITIALIZE-INFO SLOT10|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT1|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT0| PCL::|MODULE SLOT4|
-   PCL::|MODULE SLOT3| PCL::|MODULE SLOT2| PCL::SPECIALIZER-CLASS
-   PCL::|MODULE SLOT1| PCL::ACCESSOR-METHOD-SLOT-NAME
-   PCL::|MODULE SLOT0| PCL::METHOD-PROTOTYPE-FOR-GF
-   PCL::SLOT-VECTOR-SYMBOL PCL::SLOT-READER-SYMBOL
-   PCL::SPECIALIZER-FROM-TYPE PCL::INSURE-CACHING-DFUN
-   PCL::|ACCESSOR-DFUN-INFO SLOT1| PCL::|FAST-INSTANCE-BOUNDP SLOT0|)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
-   PCL::ONE-CLASS-DFUN-INFO)) 
+   (FUNCTION ((T) (T)) (NULL)) PCL::CHECK-APPLICABLE-KEYWORDS
+   PCL::ADD-SLOT-ACCESSORS PCL::REMOVE-SLOT-ACCESSORS
+   PCL::ADD-DIRECT-SUBCLASSES PCL::REMOVE-DIRECT-SUBCLASSES
+   PCL::METHOD-FUNCTION-RETURNING-NIL PCL::UPDATE-ALL-PV-TABLE-CACHES
+   PCL::UPDATE-CPL PCL::UPDATE-SLOTS PCL::UPDATE-CLASS
+   PCL::UPDATE-STD-OR-STR-METHODS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
-   PCL::|__si::MAKE-PV-TABLE|)) 
+   (FUNCTION
+    ((T) (T))
+    (OR
+     (SIMPLE-ARRAY FIXNUM 1) (SIMPLE-ARRAY T 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-INT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT 1)
+     (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR 1) (SIMPLE-ARRAY BIT 1)
+     (SIMPLE-ARRAY NIL 1) (SYSTEM:PROPER-CONS (T) (T))
+     (SIMPLE-ARRAY CHARACTER 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR 1)
+     (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT 1)
+     (SIMPLE-ARRAY SHORT-FLOAT 1) (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT 1)
+     (SIMPLE-ARRAY LONG-FLOAT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM 1) (MEMBER NIL)))
+   PCL::COMPUTE-LAYOUT)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
-   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
+    ((T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
+   PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::SAUT-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
-   PCL::|__si::MAKE-CHECKING|)) 
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL)))
+    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::PARSE-SPECIALIZERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
-   PCL::FALSE)) 
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
+   PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P PCL::*TYPEP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
+   (FUNCTION ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
+   PCL::COPY-PV-TABLE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-DLAP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T)) (T)) SYSTEM::CLASS-PRECEDENCE-LIST SYSTEM::CLASSP
@@ -329,135 +915,198 @@
    PCL::METHOD-FUNCTION-PLIST PCL::ECD-SOURCE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
-   PCL::CACHE-VECTOR)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) &REST T)
-    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
-   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
+   (FUNCTION ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
+   PCL::COPY-N-N)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   WALKER::VARIABLE-SYMBOL-MACRO-P PCL::REMTAIL PCL::%SET-CCLOSURE
-   PCL::MAKE-DLAP-LAMBDA-LIST PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST
-   PCL::MAKE-DFUN-LAMBDA-LIST PCL::MAKE-PLIST PCL::DEFAULT-INITARGS-1
-   PCL::MEC-ALL-CLASSES PCL::DESTRUCTURE-INTERNAL
-   PCL::CLASS-CAN-PRECEDE-P WALKER:VARIABLE-LEXICAL-P
-   PCL::MEC-ALL-CLASS-LISTS PCL::NET-CONSTANT-CONVERTER
-   PCL::MEMF-CONSTANT-CONVERTER)) 
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (T)) SETF::|PCL::PLIST-VALUE|
-   SETF::|PCL::METHOD-FUNCTION-GET| WALKER::WALK-DO* WALKER::WALK-IF
-   WALKER::WALK-LAMBDA WALKER::WALK-COMPILER-LET
-   WALKER::RELIST-INTERNAL WALKER::WALK-SETQ WALKER::WALK-LET
-   WALKER::WALK-MULTIPLE-VALUE-BIND WALKER::WALK-LET*
-   WALKER::WALK-SYMBOL-MACROLET WALKER::WALK-PROG WALKER::WALK-PROG*
-   WALKER::WALK-DO WALKER::WALK-LOCALLY WALKER::WALK-MACROLET
-   WALKER::WALK-NAMED-LAMBDA WALKER::WALK-UNEXPECTED-DECLARE
-   PCL::CONVERT-TABLE PCL::OPTIMIZE-GF-CALL-INTERNAL
-   PCL::TRACE-EMF-CALL-INTERNAL PCL::SET-SLOT-VALUE
-   PCL::GET-FUNCTION-GENERATOR PCL::OBSOLETE-INSTANCE-TRAP
-   PCL::FLUSH-CACHE-TRAP PCL::SET-FUNCTION-NAME-1
-   PCL::SORT-APPLICABLE-METHODS PCL::DECLARE-STRUCTURE
-   PCL::INVALIDATE-WRAPPER
-   PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
-   PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
-   PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
-   PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
-   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
-   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
-   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
-   PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
-   PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
-   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
-   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
-   PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
-   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
-   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
-   PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
-   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
-   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
-   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
-   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
-   PCL::SET-SLOT-VALUE-NORMAL)) 
+   (FUNCTION ((T) (T) (STRUCTURE) (T)) NIL)
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
-   PCL::|__si::MAKE-DFUN-INFO|)) 
+   (FUNCTION NIL (NULL)) PCL::SHOW-EMF-CALL-TRACE PCL::RENEW-SYS-FILES
+   PCL::BOOTSTRAP-BUILT-IN-CLASSES PCL::SHOW-DFUN-CONSTRUCTORS
+   PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) &REST T) (T)) PCL::ADD-NAMED-METHOD
-   PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE)) 
+   (FUNCTION ((T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-FETCH-WRAPPER PCL::MAKE-EMF-CALL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
-   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
+   (FUNCTION ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
-   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES &REST T))
+   SETF::|PCL::SLOT-VALUE-USING-CLASS| WALKER::WALK-TEMPLATE
+   PCL:MAKE-METHOD-LAMBDA PCL::GENERATE-DISCRIMINATION-NET
+   PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION PCL::INVALID-QUALIFIERS
+   PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|
+   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
+   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
+   PCL::SET-CLASS-SLOT-VALUE-1 PCL::ACCESSOR-MISS
+   PCL::%INVALID-QUALIFIERS PCL::BOOTSTRAP-ACCESSOR-DEFINITION
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
+   PCL::|(FAST-METHOD NO-PRIMARY-METHOD (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
+   PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
+   PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
+   PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::PV-TABLE))
+   PCL::MAKE-PV-TABLE-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::PRECOMPUTE-EFFECTIVE-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) &REST T) (NOT (MEMBER NIL)))
    PCL::PV-TABLE-LOOKUP-PV-ARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
-   ITERATE::SEQUENCE-ACCESSOR)) 
+   (FUNCTION
+    ((T))
+    (OR
+     (SYSTEM:COMPLEX* (LONG-FLOAT * *) (LONG-FLOAT * *))
+     (SYSTEM:COMPLEX* (RATIO * *) (RATIO * *))
+     (SYSTEM:COMPLEX* (RATIO * *) (INTEGER * *)) (LONG-FLOAT * *)
+     (RATIO * *) (INTEGER * *) (SHORT-FLOAT * *)
+     (SYSTEM:COMPLEX* (INTEGER * *) (RATIO * *))
+     (SYSTEM:COMPLEX* (INTEGER * *) (INTEGER * *))
+     (SYSTEM:COMPLEX* (SHORT-FLOAT * *) (SHORT-FLOAT * *))
+     (MEMBER NIL)))
+   PCL::COUNT-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
-   PCL::|__si::MAKE-ONE-INDEX|)) 
+   (FUNCTION ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
+   PCL::COPY-CACHING)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::FAST-METHOD-CALL)) (T))
-   PCL::FAST-METHOD-CALL-ARG-INFO
-   PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
-   PCL::FAST-METHOD-CALL-PV-CELL)) 
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T) (T))
+    (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-GREATER-THAN-1-DLAP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::MAKE-CPD)) 
 (PROCLAIM
  '(FTYPE (FUNCTION ((T) (T)) (VALUES (T) (T))) PCL::COMPUTE-CODE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
-   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN)) 
+    ((T) (T) (T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-BINDINGS-1 PCL::OPTIMIZE-GENERIC-FUNCTION-CALL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (VALUES &REST T))
+   PCL::GENERATE-DISCRIMINATION-NET-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
     (OR
      (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
      (NULL)))
-   WALKER::WALK-TAGBODY WALKER::WALK-TAGBODY-1 WALKER::WALK-LABELS
-   WALKER::WALK-FLET WALKER::RECONS WALKER:VARIABLE-DECLARATION
-   PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
-   PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| 
-   PCL::CAN-OPTIMIZE-ACCESS)) 
+   ITERATE::FUNCTION-LAMBDA-P)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (OR
-     (OR
-      (MEMBER "is not a symbol and so cannot be bound")
-      (MEMBER "is a keyword and so cannot be bound")
-      (MEMBER "is a constant and so cannot be bound")
-      (MEMBER "cannot be bound"))
-     (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|)) 
+   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
+   PCL::GENERIC-FUNCTION-NREQ)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE))
-   PCL::|STRUCTURE-OBJECT class constructor|)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     &OPTIONAL (T) (T) (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   ITERATE::EXPAND-INTO-LET)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
-   PCL::COPY-CACHE-INTERNAL)) 
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     (T)
+     (OR
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::EXTRACT-DECLARATIONS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -472,211 +1121,163 @@
    PCL::MAKE-FINAL-CACHING-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|)) 
+   (FUNCTION
+    NIL
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (NULL)))
+   PCL::EMIT-N-N-WRITERS PCL::EMIT-N-N-READERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CHECKING)) (STRUCTURE PCL::CHECKING))
-   PCL::COPY-CHECKING)) 
+   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::CAPITALIZE-WORDS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (STRUCTURE PCL::ONE-CLASS))
-   PCL::COPY-ONE-CLASS)) 
+   (FUNCTION NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
+   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
+   PCL::INTERNED-SYMBOL-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (VALUES (T) (T) (T)))
-   PCL::PARSE-METHOD-OR-SPEC)) 
+   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
+   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
-   PCL::BOOTSTRAP-SLOT-INDEX)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL))
+   PCL::|__si::MAKE-INITIAL|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM
-   PCL::MAKE-DEFMETHOD-FORM-INTERNAL)) 
+   (FUNCTION ((T) (T)) NIL) PCL::NO-SLOT PCL::CPL-INCONSISTENT-ERROR
+   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
-   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::COPY-CONSTANT-VALUE)) 
+   (FUNCTION ((T)) (OR (INTEGER 6 6) (INTEGER 4 4) (INTEGER 1 1)))
+   PCL::PV-CACHE-LIMIT-FN PCL::ONE-INDEX-LIMIT-FN PCL::CACHING-LIMIT-FN
+   PCL::DEFAULT-LIMIT-FN PCL::N-N-ACCESSORS-LIMIT-FN
+   PCL::CHECKING-LIMIT-FN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (NULL))
-   WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
-   PCL::RESET-CLASS-INITIALIZE-INFO PCL::UPDATE-GFS-OF-CLASS
-   PCL::FREE-CACHE PCL::DO-STANDARD-DEFSETF-1
-   PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS PCL::BOOTSTRAP-CLASS-PREDICATES
-   PCL::FUNCTION-RETURNING-NIL PCL::UPDATE-PV-TABLE-CACHE-INFO
-   PCL::FREE-CACHE-VECTOR PCL::COMPUTE-STD-CPL-PHASE-2
-   PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES
-   PCL::GET-MAKE-INSTANCE-FUNCTIONS PCL::FUNCTION-PRETTY-ARGLIST
-   PCL::RESET-CLASS-INITIALIZE-INFO-1
-   PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS
-   PCL::UPDATE-CLASS-CAN-PRECEDE-P)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (T)) PCL::ONE-CLASS-CACHE
-   PCL::ONE-CLASS-INDEX PCL::ONE-CLASS-WRAPPER0
-   PCL::ONE-CLASS-ACCESSOR-TYPE)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER :INSTANCE))
+   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::|__si::MAKE-CONSTANT-VALUE|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO)) (T))
-   PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::ONE-INDEX-DFUN-INFO-INDEX
-   PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE)) 
+   (FUNCTION ((T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
+   (FUNCTION ((T)) (VALUES (T) (T)))
+   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) &REST T)
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
-   PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
+    ((T) (T) (T))
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::CHANGE-CLASS-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
-   PCL::MAKE-FAST-METHOD-CALL)) 
+   (FUNCTION ((T) (T) (T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::CHECK-INITARGS-2-PLIST PCL::CHECK-INITARGS-2-LIST
+   PCL::CHECK-INITARGS-1)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (OR
-       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)
-       (STRUCTURE PCL::CHECKING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::NO-METHODS))
-      (MEMBER NIL))))
-   PCL::MAKE-FINAL-DFUN-INTERNAL)) 
+    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
+   PCL::SYMBOL-OR-CONS-LESSP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     &REST T)
-    (VALUES
-     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::PARSE-SPECIALIZED-LAMBDA-LIST)) 
+    ((T) (T) (T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-ARGLIST PCL::CAN-OPTIMIZE-ACCESS1)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::INITIAL)) (T)) PCL::INITIAL-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
-   PCL::TWO-CLASS-DFUN-INFO)) 
+    ((T) (T))
+    (VALUES
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (SYSTEM:TRUE)))
+   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR
-     (SIMPLE-ARRAY FIXNUM 1) (SIMPLE-ARRAY T 1)
-     (SIMPLE-ARRAY SYSTEM:SIGNED-INT 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT 1)
-     (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT 1)
-     (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR 1) (SIMPLE-ARRAY BIT 1)
-     (SIMPLE-ARRAY NIL 1) (SYSTEM:PROPER-CONS (T) (T))
-     (SIMPLE-ARRAY CHARACTER 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR 1)
-     (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR 1)
-     (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT 1)
-     (SIMPLE-ARRAY SHORT-FLOAT 1) (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT 1)
-     (SIMPLE-ARRAY LONG-FLOAT 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM 1) (MEMBER NIL)))
-   PCL::EARLY-COLLECT-DEFAULT-INITARGS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (STRUCTURE) (T)) NIL)
-   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
+    (&REST T)
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::MAKE-PROGN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
-   PCL::CHECKING-DFUN-INFO)) 
+   (FUNCTION ((STRUCTURE PCL::METHOD-CALL)) (T))
+   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (INTEGER 6 6) (INTEGER 4 4) (INTEGER 1 1)))
-   PCL::PV-CACHE-LIMIT-FN PCL::ONE-INDEX-LIMIT-FN PCL::CACHING-LIMIT-FN
-   PCL::DEFAULT-LIMIT-FN PCL::N-N-ACCESSORS-LIMIT-FN
-   PCL::CHECKING-LIMIT-FN)) 
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (SIMPLE-ARRAY T (6)))
-   PCL::MAKE-FGEN)) 
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::ONE-CLASS-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (VALUES
-     &OPTIONAL
-     (OR
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-      (SYSTEM:INTERPRETED-FUNCTION))
-     (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::COMPILE-LAMBDA)) 
+    ((T) (T) (T) (T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::MAKE-DISPATCH-LAMBDA)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
+   PCL::CACHE-NKEYS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION)) 
+   (FUNCTION ((T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   ITERATE::VARIABLE-SAME-P PCL::SKIP-FAST-SLOT-ACCESS-P
+   PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P PCL::ENTRY-IN-CACHE-P
+   PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
-   PCL::FILL-CACHE)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO1)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
-   PCL::COPY-STD-INSTANCE)) 
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHE)) (T)) PCL::CACHE-OWNER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
+   (FUNCTION
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM)))
-    (VALUES &REST T))
-   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|)) 
+    ((T))
+    (OR
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::GDEFINITION PCL::UNENCAPSULATED-FDEFINITION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -692,303 +1293,202 @@
    PCL::MAKE-FINAL-CHECKING-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:TRUE))
-   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
-   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
+   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
-   PCL::CHECK-CACHE)) 
+   (FUNCTION
+    ((STRUCTURE PCL::FAST-METHOD-CALL))
+    (OR
+     (OR
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::FAST-METHOD-CALL-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     &OPTIONAL
-     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))
-     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
-   PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P PCL::*TYPEP)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))
-     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
-   PCL::*SUBTYPEP PCL::SAUT-CLASS-EQ PCL::SAUT-EQL)) 
+   (FUNCTION ((T) (T) (T) (T) (T) &REST T) (T))
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES &OPTIONAL (T) (T) (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
-   PCL::CACHE-MISS-VALUES)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (T))
+   PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
+   PCL::LOAD-DEFCLASS PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION
+   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::REAL-LOAD-DEFCLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) NIL) PCL::NO-SLOT PCL::CPL-INCONSISTENT-ERROR
-   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR)) 
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
+   PCL::CHECKING-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
+   PCL::CACHE-MISS-VALUES-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
+    ((T) (T) (T) (T) &REST T)
     (VALUES
-     &OPTIONAL
-     (OR
-      (SYSTEM:HASH-TABLE-EQUALP) (SYSTEM:HASH-TABLE-EQL)
-      (SYSTEM:HASH-TABLE-EQ) (SYSTEM:HASH-TABLE-EQUAL) (MEMBER NIL))
-     (T) (T) (T) (OR (INTEGER 0 9223372036854775807) (MEMBER NIL))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::MAKE-ACCESSOR-TABLE)) 
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   ITERATE::RENAME-LET-BINDINGS)) 
 (PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (STRUCTURE PCL::N-N)) PCL::N-N-DFUN-INFO)) 
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::INITIAL)) (T)) PCL::INITIAL-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::TWO-CLASS))
-   PCL::|__si::MAKE-TWO-CLASS|)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::RESET-INITIALIZE-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-NOT)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
-   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
+    ((T) (T) (T))
+    (VALUES (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (NULL)))
+   PCL::EMIT-READER/WRITER-FUNCTION
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (T)) SETF::|PCL::INITIALIZE-INFO SLOT5|
-   SETF::|PCL::SYSTEM:S-DATA SLOT3| SETF::|PCL::GDEFINITION|
-   SETF::|PCL::ONE-INDEX-DFUN-INFO SLOT2| SETF::|PCL::ARG-INFO SLOT5|
-   SETF::|PCL::FAST-METHOD-CALL SLOT2|
-   SETF::|PCL::CLASS-DEFSTRUCT-CONSTRUCTOR| SETF::|PCL::PV-TABLE SLOT1|
-   SETF::|PCL::MODULE SLOT2| SETF::|PCL::CACHE SLOT7|
-   SETF::|PCL::COMPILER::FN SLOT2| SETF::|PCL::SYSTEM:S-DATA SLOT13|
-   SETF::|PCL::SLOT-DEFINITION-LOCATION|
-   SETF::|PCL::SLOT-DEFINITION-READER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-WRITER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-BOUNDP-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-ALLOCATION|
-   SETF::|PCL::SLOT-DEFINITION-INITFUNCTION|
-   SETF::|PCL::INITIALIZE-INFO SLOT3| SETF::|PCL::SYSTEM:S-DATA SLOT1|
-   SETF::|PCL::GF-PRETTY-ARGLIST| SETF::|PCL::ARG-INFO SLOT3|
-   SETF::|PCL::FAST-METHOD-CALL SLOT0|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT3|
-   SETF::|PCL::INITIALIZE-INFO SLOT13| SETF::|PCL::MODULE SLOT0|
-   SETF::|PCL::CACHE SLOT5| SETF::|PCL::COMPILER::FN SLOT0|
-   SETF::|PCL::SYSTEM:S-DATA SLOT11|
-   SETF::|PCL::SLOT-DEFINITION-INITFORM|
-   SETF::|PCL::INITIALIZE-INFO SLOT1| SETF::|PCL::ARG-INFO SLOT1|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT1|
-   SETF::|PCL::OBJECT-PLIST| SETF::|PCL::SYSTEM:S-DATA SLOT8|
-   SETF::|PCL::INITIALIZE-INFO SLOT11| SETF::|PCL::CACHE SLOT3|
-   SETF::|PCL::GENERIC-FUNCTION-METHOD-CLASS|
-   SETF::|PCL::ACCESSOR-DFUN-INFO SLOT1|
-   SETF::|PCL::FIND-CLASS-PREDICATE| SETF::|PCL::GENERIC-FUNCTION-NAME|
-   SETF::|PCL::COMPILER::FN SLOT7| SETF::|PCL::METHOD-CALL SLOT1|
-   SETF::|PCL::FAST-INSTANCE-BOUNDP SLOT0|
-   SETF::|PCL::INITIALIZE-INFO SLOT8| SETF::|PCL::SYSTEM:S-DATA SLOT6|
-   SETF::|PCL::CACHE SLOT1| SETF::|PCL::ARG-INFO SLOT8|
-   SETF::|PCL::SLOT-DEFINITION-TYPE|
-   SETF::|PCL::SLOT-DEFINITION-READERS|
-   SETF::|PCL::SLOT-DEFINITION-WRITERS|
-   SETF::|PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL|
-   SETF::|PCL::COMPILER::FN SLOT5| SETF::|PCL::SYSTEM:S-DATA SLOT16|
-   SETF::|PCL::CACHE SLOT11| SETF::|PCL::CHECKING SLOT1|
-   SETF::|PCL::INITIALIZE-INFO SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT4|
-   SETF::|PCL::ARG-INFO SLOT6| SETF::|PCL::FAST-METHOD-CALL SLOT3|
-   SETF::|PCL::PV-TABLE SLOT2| SETF::|PCL::MODULE SLOT3|
-   SETF::|PCL::CACHE SLOT8| SETF::|PCL::COMPILER::FN SLOT3|
-   SETF::|PCL::SYSTEM:S-DATA SLOT14| SETF::|PCL::INITIALIZE-INFO SLOT4|
-   SETF::|PCL::SYSTEM:S-DATA SLOT2| SETF::|PCL::TWO-CLASS SLOT4|
-   SETF::|PCL::CLASS-DIRECT-SLOTS| SETF::|PCL::CLASS-SLOTS|
-   SETF::|PCL::ONE-CLASS SLOT3| SETF::|PCL::METHOD-GENERIC-FUNCTION|
-   SETF::|PCL::ARG-INFO SLOT4| SETF::|PCL::FAST-METHOD-CALL SLOT1|
-   SETF::|COMMON-LISP::CLASS-NAME|
-   SETF::|PCL::GENERIC-FUNCTION-METHOD-COMBINATION|
-   SETF::|PCL::PV-TABLE SLOT0| SETF::|PCL::MODULE SLOT1|
-   SETF::|PCL::CACHE SLOT6| SETF::|PCL::COMPILER::FN SLOT1|
-   SETF::|PCL::SYSTEM:S-DATA SLOT12| SETF::|PCL::CLASS-DEFSTRUCT-FORM|
-   SETF::|PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST|
-   SETF::|PCL::INITIALIZE-INFO SLOT2|
-   SETF::|PCL::SLOT-DEFINITION-INITARGS|
-   SETF::|PCL::SYSTEM:S-DATA SLOT0| SETF::|PCL::ARG-INFO SLOT2|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT2|
-   SETF::|PCL::SYSTEM:S-DATA SLOT9| SETF::|PCL::INITIALIZE-INFO SLOT12|
-   SETF::|PCL::CACHE SLOT4| SETF::|PCL::METHOD-FUNCTION-PLIST|
-   SETF::|PCL::SYSTEM:S-DATA SLOT10| SETF::|PCL::INITIALIZE-INFO SLOT0|
-   SETF::|PCL::SLOT-DEFINITION-CLASS| SETF::|PCL::COMPILER::FN SLOT8|
-   SETF::|PCL::ARG-INFO SLOT0| SETF::|PCL::SLOT-DEFINITION-NAME|
-   SETF::|PCL::INITIALIZE-INFO SLOT9|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT0|
-   SETF::|PCL::SYSTEM:S-DATA SLOT7| SETF::|PCL::INITIALIZE-INFO SLOT10|
-   SETF::|PCL::CACHE SLOT2| SETF::|PCL::ARG-INFO SLOT9|
-   SETF::|PCL::ARG-INFO SLOT10|
-   SETF::|PCL::GENERIC-FUNCTION-INITIAL-METHODS|
-   SETF::|PCL::GENERIC-FUNCTION-METHODS|
-   SETF::|PCL::COMPILER::FN SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT17|
-   SETF::|PCL::METHOD-CALL SLOT0| SETF::|PCL::INITIALIZE-INFO SLOT7|
-   SETF::|PCL::SYSTEM:S-DATA SLOT5| SETF::|PCL::CACHE SLOT0|
-   SETF::|PCL::ARG-INFO SLOT7| SETF::|PCL::CLASS-INITIALIZE-INFO|
-   SETF::|PCL::GF-DFUN-STATE| SETF::|PCL::PV-TABLE SLOT3|
-   SETF::|PCL::MODULE SLOT4| SETF::|PCL::CACHE SLOT9|
-   SETF::|PCL::COMPILER::FN SLOT4| SETF::|PCL::SYSTEM:S-DATA SLOT15|
-   SETF::|PCL::CACHE SLOT10| SETF::|PCL::DFUN-INFO SLOT0|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SLOTS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot WRITER|
-   WALKER::ENVIRONMENT-FUNCTION WALKER::ENVIRONMENT-MACRO
-   ITERATE::MV-SETQ SLOT-BOUNDP
-   PCL:FUNCALLABLE-STANDARD-INSTANCE-ACCESS SLOT-MAKUNBOUND
-   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::VARIABLE-CLASS
-   PCL::COMPUTE-APPLICABLE-KEYWORDS PCL::COMPUTE-CONSTANTS
-   PCL::FDEFINE-CAREFULLY PCL::SET-INITIAL-METHODS
-   PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P PCL::PROCLAIM-DEFMETHOD
-   PCL::DESCRIBE-PACKAGE PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER
-   PCL::%CCLOSURE-ENV-NTHCDR PCL::MAP-PV-TABLE-REFERENCES-OF
-   PCL::AUGMENT-TYPE PCL::GET-KEY-ARG-TAIL PCL::VALUE-FOR-CACHING
-   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::REAL-REMOVE-METHOD
-   PCL::SET-METHODS PCL::SET-STRUCTURE-SVUC-METHOD PCL::COMPUTE-PV
-   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION
-   PCL::SWAP-WRAPPERS-AND-SLOTS PCL::REDIRECT-EARLY-FUNCTION-INTERNAL
-   WALKER:VARIABLE-SPECIAL-P PCL::LEGAL-LAMBDA-LIST-P
-   PCL::FIND-STANDARD-II-METHOD PCL::SLOT-BOUNDP-NORMAL
-   PCL::SET-STANDARD-SVUC-METHOD PCL::PROCLAIM-DEFGENERIC
-   PCL::SET-WRAPPER PCL::ADD-FORMS PCL::MAKE-CLASS-PREDICATE
-   PCL::UPDATE-INITS PCL::REDEFINE-FUNCTION
-   PCL::SET-FUNCTION-PRETTY-ARGLIST PCL::PRINTING-RANDOM-THING-INTERNAL
-   PCL::SLOT-UNBOUND-INTERNAL PCL::PLIST-VALUE PCL::MAKE-CDXR
-   PCL::FIND-SLOT-DEFINITION PCL::SET-FUNCTION-NAME)) 
+   (FUNCTION ((T) (T)) (OR (SYSTEM:TRUE) (NULL))) SLOT-EXISTS-P
+   PCL::SUPERCLASSES-COMPATIBLE-P PCL::DO-SATISFIES-DEFTYPE
+   PCL::QUALIFIER-CHECK-RUNTIME PCL::SAUT-NOT-CLASS-EQ
+   PCL::SAUT-NOT-EQL PCL::SAUT-NOT-PROTOTYPE PCL::SAUT-NOT-CLASS
+   PCL::LIST-EQ)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
-    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::COMPUTE-STD-CPL-PHASE-3)) 
+    ((OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     &REST T)
+    (VALUES &REST T))
+   PCL::MAP-ALL-CLASSES)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T) &REST T)
     (VALUES
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|)) 
+     (STRUCTURE PCL::ARG-INFO)))
+   PCL::TYPES-FROM-ARGUMENTS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (T))
+   PCL::LOAD-DEFMETHOD-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES))
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|)) 
+   (FUNCTION ((T) (T)) (VALUES &REST T))
+   PCL:COMPUTE-APPLICABLE-METHODS-USING-CLASSES PCL:MAP-DEPENDENTS
+   PCL:REMOVE-DIRECT-SUBCLASS PRINT-OBJECT
+   PCL:COMPUTE-EFFECTIVE-SLOT-DEFINITION PCL:REMOVE-DIRECT-METHOD
+   PCL:VALIDATE-SUPERCLASS PCL:ADD-DIRECT-SUBCLASS ADD-METHOD
+   PCL:ADD-DIRECT-METHOD PCL:ADD-DEPENDENT PCL:REMOVE-DEPENDENT
+   SLOT-VALUE PCL:EFFECTIVE-SLOT-DEFINITION-CLASS
+   PCL:DIRECT-SLOT-DEFINITION-CLASS REMOVE-METHOD
+   COMPUTE-APPLICABLE-METHODS DESCRIBE-OBJECT
+   PCL::LEGAL-DOCUMENTATION-P PCL::REMOVE-BOUNDP-METHOD
+   PCL::%NO-PRIMARY-METHOD PCL::LEGAL-SPECIALIZER-P
+   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
+   PCL::MAKE-DIRECT-SLOTD PCL::LEGAL-QUALIFIER-P PCL::CLASS-SLOT-VALUE
+   PCL::DEFAULT-INITARGS PCL::UPDATE-SLOT-VALUE-GF-INFO
+   PCL::LEGAL-SLOT-NAME-P PCL::COMPUTE-TEST PCL::SLOTS-TO-INSPECT
+   PCL::SAME-SPECIALIZER-P PCL::SDFUN-FOR-CACHING
+   PCL::LEGAL-METHOD-FUNCTION-P PCL::MAKE-READER-METHOD-FUNCTION
+   PCL::SLOT-ACCESSOR-FUNCTION PCL::SLOT-ACCESSOR-STD-P
+   PCL::LEGAL-SPECIALIZERS-P PCL::MAKE-WRITER-METHOD-FUNCTION
+   PCL::LEGAL-QUALIFIERS-P PCL::INVOKE-EMF
+   PCL::MAKE-BOUNDP-METHOD-FUNCTION PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS
+   DOCUMENTATION PCL::SLOT-VALUE-NORMAL
+   PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::REMOVE-WRITER-METHOD
+   PCL::UPDATE-GF-DFUN PCL::INITIAL-DFUN PCL::REMOVE-READER-METHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (VALUES &REST T))
-   ITERATE::ITERATE-TRANSFORM-BODY
-   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|)) 
+   (FUNCTION
+    ((T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-CONSTANT-VALUE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (T)) PCL::PV-WRAPPERS-FROM-PV-ARGS
-   PCL::UNTRACE-METHOD PCL::INTERN-PV-TABLE PCL::LOAD-TRUENAME)) 
+   (FUNCTION ((T) (T)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL PCL::ENSURE-CLASS-VALUES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (NOT (MEMBER NIL))) PCL::EARLY-CLASS-DEFINITION
-   PCL::GET-PV-CELL-FOR-CLASS)) 
+   (FUNCTION
+    ((T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (VALUES &REST T)) ENSURE-GENERIC-FUNCTION
-   MAKE-INSTANCE REINITIALIZE-INSTANCE INITIALIZE-INSTANCE
-   ALLOCATE-INSTANCE PCL:ENSURE-CLASS MAKE-LOAD-FORM
-   PCL::CALL-NO-NEXT-METHOD PCL::DISPATCH-DFUN-COST
-   PCL::NO-PRIMARY-METHOD PCL::MAKE-TYPE-PREDICATE-NAME
-   WALKER:WALK-FORM PCL::MAKE-METHOD-FUNCTION-INTERNAL
-   PCL::MAKE-INSTANCE-1 PCL::COERCE-TO-CLASS
-   PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
-   PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T| 
-   PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
-   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
-   WALKER:MACROEXPAND-ALL
-   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION) T|
-   PCL::GET-DFUN-CONSTRUCTOR
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :NAME :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :INITFUNCTION :NAME :READERS :WRITERS :INITARGS :INITFORM) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:LAMBDA-LIST :DEFINITION-SOURCE) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :FUNCTION :DEFINITION-SOURCE) NIL|
-   PCL::|MAKE-INSTANCE STRUCTURE-EFFECTIVE-SLOT-DEFINITION (:DEFSTRUCT-ACCESSOR-SYMBOL :INTERNAL-READER-FUNCTION :INTERNAL-WRITER-FUNCTION :NAME :INITFORM :INITFUNCTION :INITARGS :ALLOCATION :TYPE :CLASS) NIL|
-   PCL::|MAKE-INSTANCE STRUCTURE-DIRECT-SLOT-DEFINITION (:CLASS :NAME :DEFSTRUCT-ACCESSOR-SYMBOL :INTERNAL-READER-FUNCTION :INTERNAL-WRITER-FUNCTION :TYPE :INITFORM :INITFUNCTION) NIL|
-   PCL::|MAKE-INSTANCE STRUCTURE-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :NAME) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :NAME) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-EFFECTIVE-SLOT-DEFINITION (:NAME :INITFORM :INITFUNCTION :INITARGS :ALLOCATION :TYPE :CLASS) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :NAME :READERS :WRITERS :INITARGS) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE :PREDICATE-NAME) NIL|
-   PCL::|MAKE-INSTANCE EQL-SPECIALIZER (:OBJECT) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST) NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION NIL NIL|
-   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS) NIL|
-   PCL::|MAKE-INSTANCE CLASS-EQ-SPECIALIZER (:CLASS) NIL|
-   PCL::GET-FUNCTION)) 
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
+   PCL::COPY-STD-INSTANCE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
-    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
-   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-   PCL::MAKE-FAST-INSTANCE-BOUNDP)) 
+    ((T) (T) (T) &REST T)
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
+   PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) &REST T)
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   WALKER::WALK-ARGLIST PCL::CAN-OPTIMIZE-ACCESS1)) 
+    ((INTEGER 0 9223372036854775807) (T) &REST T)
+    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::FIND-FREE-CACHE-LINE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
-   PCL::GENERIC-FUNCTION-NREQ)) 
+   (FUNCTION ((T) (T) (T) (T) (STRUCTURE) (T)) (VALUES &REST T))
+   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
-   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
+   (FUNCTION ((T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
+   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
+   PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::ACCESSOR-VALUES1 PCL::ACCESSOR-VALUES-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (T) (T))
-    (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-GREATER-THAN-1-DLAP)) 
+   (FUNCTION ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::EXPAND-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
-   PCL::N-N-ACCESSOR-TYPE)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
+   PCL::MAKE-INSTANCE-FUNCTION-COMPLEX)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
-   PCL::COPY-PV-TABLE)) 
+   (FUNCTION ((T) (T) (T) (T) &REST T) (VALUES &REST T))
+   UPDATE-INSTANCE-FOR-REDEFINED-CLASS
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1
+   PCL::EARLY-ADD-NAMED-METHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::ENSURE-CLASS-VALUES)) 
+   (FUNCTION ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
+   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES
-     &OPTIONAL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (NULL)))
-   PCL::EMIT-READER/WRITER-FUNCTION
-   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION)) 
+   (FUNCTION ((T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-SHORT-DEFCOMBIN PCL::EXPAND-LONG-DEFCOMBIN
+   PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST PCL::GET-SETF-FUNCTION-NAME
+   PCL::MAKE-PV-TYPE-DECLARATION PCL::COMPUTE-MCASE-PARAMETERS
+   PCL::MAKE-PV-TABLE-TYPE-DECLARATION PCL::MAKE-CALL-METHODS
+   PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD
+   PCL::MAKE-CALLS-TYPE-DECLARATION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T))
     (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
+     (INTEGER 0 268435455) (T)
      (OR
       (OR
        (OR
@@ -1011,118 +1511,110 @@
         (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
         (SYSTEM::NON-SIMPLE-ARRAY T *)
         (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
-   PCL::DESTRUCTURE)) 
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (INTEGER 0 268435455) (STRUCTURE PCL::ARG-INFO)))
+   PCL::GET-GENERIC-FUNCTION-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
-    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
-   PCL::CHANGE-CLASS-INTERNAL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
+    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
+     (T))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T) (T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION PCL::MEMF-CODE-CONVERTER)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
-   PCL::COPY-ONE-INDEX)) 
+    ((T)) (OR (SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY T *)))
+   PCL::ALLOCATE-CACHE-VECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
+   (FUNCTION
+    ((T) (T))
+    (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::CLASS-MIGHT-PRECEDE-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
+    ((T) (T) (T))
+    (OR
+     (OR
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (MEMBER #())) PCL::COMPUTE-CALLS)) 
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::SORT-APPLICABLE-METHODS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
-   PCL::SET-ARG-INFO1)) 
+   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T))
-    (OR
-     (SIMPLE-ARRAY FIXNUM 1) (SIMPLE-ARRAY T 1)
-     (SIMPLE-ARRAY SYSTEM:SIGNED-INT 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT 1)
-     (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT 1)
-     (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR 1) (SIMPLE-ARRAY BIT 1)
-     (SIMPLE-ARRAY NIL 1) (SYSTEM:PROPER-CONS (T) (T))
-     (SIMPLE-ARRAY CHARACTER 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR 1)
-     (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR 1)
-     (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT 1)
-     (SIMPLE-ARRAY SHORT-FLOAT 1) (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT 1)
-     (SIMPLE-ARRAY LONG-FLOAT 1)
-     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM 1) (MEMBER NIL)))
-   PCL::COMPUTE-LAYOUT)) 
+    (VALUES
+     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   ITERATE::PARSE-DECLARATIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((INTEGER 0 9223372036854775807) (T) (T))
-    (VALUES
-     (INTEGER 0 9223372036854775807) (INTEGER 0 9223372036854775807)
-     (INTEGER 1 4611686018427387904) (INTEGER 0 9223372036854775807)))
-   PCL::COMPUTE-CACHE-PARAMETERS)) 
+   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::COPY-TWO-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
+   (FUNCTION ((T) (T) (T) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::FILL-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::CACHES-TO-ALLOCATE)) 
+   (FUNCTION ((T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
+   (FUNCTION ((STRUCTURE PCL::ACCESSOR-DFUN-INFO)) (T))
+   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
-   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::MAKE-INITIALIZE-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|)) 
+   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
+   PCL::|__si::MAKE-STD-INSTANCE|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO)) (T))
+   PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::ONE-INDEX-DFUN-INFO-INDEX
+   PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
+    ((T) (T))
     (VALUES
-     (INTEGER 0 *) (INTEGER 0 *) (OR (SYSTEM:TRUE) (NULL))
-     (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::ANALYZE-LAMBDA-LIST)) 
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   PCL::SPLIT-DECLARATIONS)) 
+(PROCLAIM '(FTYPE (FUNCTION ((T) (T) &REST T) NIL) PCL::CPL-ERROR)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
    PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
    PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
    PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
    PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
    PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
@@ -1130,256 +1622,219 @@
    PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY CHARACTER (*)))
-   PCL::CAPITALIZE-WORDS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-FETCH-WRAPPER PCL::MAKE-EMF-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
-   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
    (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
+    ((STRUCTURE PCL::CACHE))
+    (OR
      (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (T))
-    (NULL))
-   PCL::%CHECK-CNM-ARGS)) 
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::CACHE-LIMIT-FN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (STRUCTURE PCL::ARG-INFO)))
-   PCL::TYPES-FROM-ARGUMENTS)) 
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (T)) PCL::CHECKING-CACHE
+   PCL::CHECKING-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (T))
-   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION ((T) (T) (T) &REST T) (VALUES &REST T))
+   WALKER::WALK-DECLARATIONS FIND-METHOD PCL::GET-METHOD
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (T)) PCL::%%ALLOCATE-INSTANCE--CLASS
-   PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
-   PCL::GET-EFFECTIVE-METHOD-GENSYM PCL::IN-THE-COMPILER-P
-   PCL::BOOTSTRAP-META-BRAID PCL::LIST-ALL-DFUNS)) 
+   (FUNCTION ((T)) (INTEGER 0 268435455)) PCL::EARLY-CLASS-SIZE
+   PCL::ARG-INFO-NKEYS PCL::ARG-INFO-NUMBER-REQUIRED)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE) (T)) (T))
-   PCL:STANDARD-INSTANCE-ACCESS)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (T)) PCL::ONE-CLASS-CACHE
+   PCL::ONE-CLASS-INDEX PCL::ONE-CLASS-WRAPPER0
+   PCL::ONE-CLASS-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
-   PCL::STRING-APPEND)) 
+   (FUNCTION
+    ((T) (T)
+     (OR
+      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
+     (T) (T))
+    (VALUES
+     (INTEGER -9223372036854775808 9223372036854775807) (T) (T)))
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER :INSTANCE))
-   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
+   (FUNCTION
+    ((T))
+    (OR
+     (OR
+      (OR
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::SORT-CALLS PCL::METHOD-LL->GENERIC-FUNCTION-LL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::MAKE-INITIALIZE-INFO)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (VALUES &REST T))
+   WALKER::WALK-TEMPLATE-HANDLE-REPEAT PCL::WALK-METHOD-LAMBDA
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
+   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+   PCL::MAKE-METHOD-INITARGS-FORM
+   PCL::|(FAST-METHOD NO-NEXT-METHOD (STANDARD-GENERIC-FUNCTION STANDARD-METHOD))|
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (INTEGER 0 9223372036854775807) &REST T)
-    (STRUCTURE PCL::CACHE))
-   PCL::GET-CACHE-FROM-CACHE)) 
+    ((OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
-   PCL::POWER-OF-TWO-CEILING)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::METHOD-CALL))
+   PCL::MAKE-METHOD-CALL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T)
-     (OR
-      (BROADCAST-STREAM) (CONCATENATED-STREAM) (ECHO-STREAM)
-      (OR
-       (SYSTEM:FILE-INPUT-STREAM) (SYSTEM:FILE-OUTPUT-STREAM)
-       (SYSTEM:FILE-IO-STREAM) (SYSTEM:FILE-PROBE-STREAM))
-      (OR (SYSTEM:STRING-INPUT-STREAM) (SYSTEM:STRING-OUTPUT-STREAM))
-      (OR
-       (SYSTEM::FILE-SYNONYM-STREAM) (SYSTEM::NON-FILE-SYNONYM-STREAM))
-      (TWO-WAY-STREAM))
-     (T))
-    (NULL))
-   PCL::PRINT-DFUN-INFO)) 
+    ((T) &REST T)
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   PCL:EXTRACT-LAMBDA-LIST PCL::GFS-OF-TYPE PCL::LIST-LARGE-CACHE
-   PCL::EARLY-COLLECT-SLOTS PCL::EXPAND-MAKE-INSTANCE-FORM
-   PCL::FIND-CYCLE-REASONS)) 
+   (FUNCTION ((T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::COMPILE-LAMBDA-UNCOMPILED PCL::MAKE-EQL-PREDICATE
+   PCL::CLASS-PREDICATE PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
+   PCL::EVAL-FORM PCL::COMPILE-LAMBDA-DEFERRED PCL::MAKE-TYPE-PREDICATE
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-TRAMPOLINE PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION
+   PCL::MAKE-CLASS-EQ-PREDICATE PCL::MAKE-CONSTANT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (T)) SETF::|COMMON-LISP::FIND-CLASS|
-   WALKER::CONVERT-MACRO-TO-LAMBDA PCL::MAKE-EMF-FROM-METHOD
-   PCL::PROBE-CACHE PCL::GET-EFFECTIVE-METHOD-FUNCTION1
-   PCL::GET-METHOD-FUNCTION-PV-CELL
-   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::METHOD-FUNCTION-GET
-   PCL::REAL-ADD-METHOD PCL::GET-DECLARATION
-   PCL::FIND-CLASS-PREDICATE-FROM-CELL PCL::FIND-CLASS-FROM-CELL
-   PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
-   PCL::REAL-ENSURE-GF-USING-CLASS--NULL)) 
+   (FUNCTION (&REST T) (STRUCTURE))
+   PCL::|STRUCTURE-OBJECT class constructor|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (NULL)) ITERATE::MAYBE-WARN
-   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::SAUT-AND)) 
+    ((T))
+    (OR
+     (SIMPLE-ARRAY CHARACTER (*))
+     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
+   PCL::SYMBOL-PKG-NAME)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHING)) (T)) PCL::CACHING-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (T))
-   PCL::LOAD-DEFMETHOD-INTERNAL)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
+   PCL::CACHE-VECTOR)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
-   PCL::CACHE-LINE-SIZE)) 
+   (FUNCTION
+    ((T) (T) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (VALUES
-     (INTEGER 0 268435455) (T)
-     (OR
-      (OR
-       (OR
-        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-        (SIMPLE-ARRAY BIT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-        (SIMPLE-ARRAY SHORT-FLOAT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-        (SIMPLE-ARRAY FIXNUM (*)))
-       (OR
-        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-        (SYSTEM::NON-SIMPLE-ARRAY T *)
-        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-     (INTEGER 0 268435455) (STRUCTURE PCL::ARG-INFO)))
-   PCL::GET-GENERIC-FUNCTION-INFO)) 
+    ((T)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
+   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::MAKE-CPD)) 
+   (FUNCTION
+    ((T) (T) (T)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::FAST-METHOD-CALL))
-    (OR
-     (OR
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-     (SYSTEM:INTERPRETED-FUNCTION)))
-   PCL::FAST-METHOD-CALL-FUNCTION)) 
+    ((T) &REST T) (VALUES (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
+   PCL::GET-METHOD-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (T)) WALKER::RELIST WALKER::RELIST*
-   FIND-CLASS PCL::ALLOCATE-STRUCTURE-INSTANCE
-   PCL::ALLOCATE-STANDARD-INSTANCE PCL::EARLY-FIND-CLASS-SYMBOL
-   PCL::INITIALIZE-METHOD-FUNCTION PCL::MAKE-FINAL-DFUN
-   PCL::MAKE-SPECIALIZABLE PCL::FIND-CLASS-CELL
-   PCL::FIND-CLASS-PREDICATE PCL::UPDATE-DFUN PCL::TRACE-METHOD
-   PCL::SET-DFUN PCL::EARLY-METHOD-SPECIALIZERS)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (T)) WALKER::WALK-PROG/PROG*
-   WALKER::WALK-DO/DO* WALKER::WALK-LET/LET* PCL::BOOTSTRAP-SET-SLOT
-   PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
-   PCL::GET-WRAPPERS-FROM-CLASSES PCL::FROB-COMBINED-METHOD-ARGS
-   PCL::LOAD-LONG-DEFCOMBIN
-   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::MEMF-TEST-CONVERTER
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE PCL::OPTIMIZE-WRITER
-   PCL::OPTIMIZE-READER PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
-   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
-   PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|
-   PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
-   PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
-   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
-   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
-   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
-   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
-   PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
-   PCL::LOAD-SHORT-DEFCOMBIN)) 
+   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (INTEGER 0 9223372036854775807))
-    (STRUCTURE PCL::CACHE))
-   PCL::GET-CACHE)) 
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::INITIALIZE-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (NULL))
-   PCL::MAP-SPECIALIZERS PCL::MAP-ALL-GENERIC-FUNCTIONS)) 
+   (FUNCTION ((T)) (OR (SYSTEM:TRUE) (NULL))) PCL::EARLY-GF-P
+   PCL::METHOD-CALL-P PCL::ONE-INDEX-P PCL::STD-INSTANCE-P PCL::N-N-P
+   PCL::LEGAL-CLASS-NAME-P PCL::TWO-CLASS-P PCL::INITIALIZE-INFO-P
+   PCL::ONE-CLASS-P PCL::DISPATCH-P PCL::DEFAULT-STRUCTUREP
+   PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::DEFAULT-CONSTANTP
+   PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::STRUCTURE-TYPE-P
+   PCL::NO-METHODS-P PCL::CONSTANT-VALUE-P
+   PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P PCL::CACHING-P PCL::GBOUNDP
+   PCL::INITIAL-P PCL::DNET-METHODS-P PCL::FAST-METHOD-CALL-P
+   PCL::CCLOSUREP PCL::EARLY-METHOD-STANDARD-ACCESSOR-P
+   PCL::FUNCALLABLE-INSTANCE-P PCL::FIELD-TYPE-SIMPLE-TYPEP-FN
+   PCL::ONE-INDEX-DFUN-INFO-P PCL::UPDATE-C-A-M-GF-INFO PCL::CHECKING-P
+   PCL::COMPLICATED-INSTANCE-CREATION-METHOD PCL::INITIAL-DISPATCH-P
+   PCL::ARG-INFO-P PCL::DEFAULT-METHOD-ONLY-P PCL::STRUCTURE-OBJECT-P
+   PCL::PV-TABLEP PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS PCL::CACHE-P
+   PCL::%FBOUNDP PCL::STRUCTURE-INSTANCE-P
+   PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::ACCESSOR-DFUN-INFO-P
+   PCL::ARG-INFO-VALID-P PCL::FAST-INSTANCE-BOUNDP-P PCL::DFUN-INFO-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-CLASS))
+   PCL::|__si::MAKE-ONE-CLASS|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::COPY-DEFAULT-METHOD-ONLY)) 
+    ((T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CACHING PCL::EMIT-CHECKING)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) &REST T) (T))
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
-(PROCLAIM '(FTYPE (FUNCTION ((T) (T) &REST T) NIL) PCL::CPL-ERROR)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -1394,215 +1849,192 @@
    PCL::ADD-METHOD-DECLARATIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
-   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
+   (FUNCTION ((SYSTEM:STD-INSTANCE) (T)) (T))
+   PCL:STANDARD-INSTANCE-ACCESS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     &OPTIONAL
-     (OR
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-DEFAULT-ONLY)) 
+   (FUNCTION (&REST T) (T)) PCL::PV-WRAPPERS-FROM-PV-ARGS
+   PCL::UNTRACE-METHOD PCL::INTERN-PV-TABLE PCL::LOAD-TRUENAME)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (INTEGER 0 9223372036854775807))
-    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::FILL-CACHE-FROM-CACHE-P)) 
+    ((STRUCTURE PCL::METHOD-CALL))
+    (OR
+     (OR
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::METHOD-CALL-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::INITIAL-DISPATCH))
-    (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::COPY-INITIAL-DISPATCH)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
+    ((T) (T) (T))
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::RESET-INITIALIZE-INFO)) 
+   (FUNCTION ((T) (T)) (VALUES (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   WALKER::NOTE-DECLARATION WALKER::NOTE-LEXICAL-BINDING
-   PCL::MAKE-STD-WRITER-METHOD-FUNCTION
-   PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION
-   PCL::MAKE-STD-READER-METHOD-FUNCTION)) 
+    ((T) (T) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
+   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
-   PCL::GET-ACCESSOR-METHOD-FUNCTION)) 
+   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
+   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::PV-TABLE))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   PCL::PV-TABLE-SLOT-NAME-LISTS PCL::PV-TABLE-CALL-LIST)) 
+    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
+   PCL::COPY-CACHE-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     (T)
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))))
-   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
+    ((STRUCTURE PCL::FAST-METHOD-CALL))
+    (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::COPY-FAST-METHOD-CALL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ARG-INFO))
-   PCL::|__si::MAKE-ARG-INFO|)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (NULL)) PCL::CHECK-APPLICABLE-KEYWORDS
-   PCL::ADD-SLOT-ACCESSORS PCL::REMOVE-SLOT-ACCESSORS
-   PCL::ADD-DIRECT-SUBCLASSES PCL::REMOVE-DIRECT-SUBCLASSES
-   PCL::METHOD-FUNCTION-RETURNING-NIL PCL::UPDATE-ALL-PV-TABLE-CACHES
-   PCL::UPDATE-CPL PCL::UPDATE-SLOTS PCL::UPDATE-CLASS
-   PCL::UPDATE-STD-OR-STR-METHODS)) 
+   (FUNCTION ((T)) (NULL))
+   WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
+   PCL::RESET-CLASS-INITIALIZE-INFO PCL::UPDATE-GFS-OF-CLASS
+   PCL::FREE-CACHE PCL::DO-STANDARD-DEFSETF-1
+   PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS PCL::BOOTSTRAP-CLASS-PREDICATES
+   PCL::FUNCTION-RETURNING-NIL PCL::UPDATE-PV-TABLE-CACHE-INFO
+   PCL::FREE-CACHE-VECTOR PCL::COMPUTE-STD-CPL-PHASE-2
+   PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES
+   PCL::GET-MAKE-INSTANCE-FUNCTIONS PCL::FUNCTION-PRETTY-ARGLIST
+   PCL::RESET-CLASS-INITIALIZE-INFO-1
+   PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS
+   PCL::UPDATE-CLASS-CAN-PRECEDE-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
+    ((T))
     (OR
-     (MEMBER "is neither a class object nor an eql specializer")
-     (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|)) 
+     (SIMPLE-ARRAY FIXNUM 1) (SIMPLE-ARRAY T 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-INT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT 1)
+     (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR 1) (SIMPLE-ARRAY BIT 1)
+     (SIMPLE-ARRAY NIL 1) (SYSTEM:PROPER-CONS (T) (T))
+     (SIMPLE-ARRAY CHARACTER 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR 1)
+     (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT 1)
+     (SIMPLE-ARRAY SHORT-FLOAT 1) (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT 1)
+     (SIMPLE-ARRAY LONG-FLOAT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM 1) (MEMBER NIL)))
+   PCL::EARLY-COLLECT-DEFAULT-INITARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (OR (SYSTEM:TRUE) (NULL))) SLOT-EXISTS-P
-   PCL::SUPERCLASSES-COMPATIBLE-P PCL::DO-SATISFIES-DEFTYPE
-   PCL::QUALIFIER-CHECK-RUNTIME PCL::SAUT-NOT-CLASS-EQ
-   PCL::SAUT-NOT-EQL PCL::SAUT-NOT-PROTOTYPE PCL::SAUT-NOT-CLASS
-   PCL::LIST-EQ)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (SIMPLE-ARRAY T (6)))
+   PCL::MAKE-FGEN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T))
-    (OR
-     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-     (SYSTEM:INTERPRETED-FUNCTION)))
-   PCL::GDEFINITION PCL::UNENCAPSULATED-FDEFINITION)) 
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (NULL)))
+   PCL::EMIT-ONE-CLASS-WRITER PCL::EMIT-ONE-CLASS-READER
+   PCL::EMIT-TWO-CLASS-WRITER PCL::EMIT-TWO-CLASS-READER
+   PCL::EMIT-ONE-INDEX-WRITERS PCL::EMIT-ONE-INDEX-READERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
-   PCL::SPLIT-DECLARATIONS)) 
+   (FUNCTION ((T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   ITERATE::SIMPLE-EXPAND-ITERATE-FORM PCL::DEAL-WITH-ARGUMENTS-OPTION
+   PCL::MEC-ALL-CLASSES-INTERNAL PCL::MAKE-DFUN-ARG-LIST
+   PCL::CANONICALIZE-DEFCLASS-OPTION
+   PCL::CANONICALIZE-SLOT-SPECIFICATION
+   PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
+   PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
+   PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION PCL::EMIT-1-NIL-DLAP
+   PCL::MAKE-CAXR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::KEY-NAMES)) 
+   (FUNCTION NIL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::CACHES-TO-ALLOCATE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T)
-     (OR
-      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
-     (T) (T))
-    (VALUES
-     (INTEGER -9223372036854775808 9223372036854775807) (T) (T)))
-   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
+   PCL::|__si::MAKE-CHECKING|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR
-     (SIMPLE-ARRAY CHARACTER (*))
-     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
-   PCL::SYMBOL-PKG-NAME)) 
+    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL)))
-    (VALUES
-     (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))))
-   PCL::PARSE-DEFMETHOD)) 
+   (FUNCTION ((STRUCTURE PCL::INITIAL)) (STRUCTURE PCL::INITIAL))
+   PCL::COPY-INITIAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES &REST T))
-   SETF::|PCL::SLOT-VALUE-USING-CLASS| WALKER::WALK-TEMPLATE
-   PCL:MAKE-METHOD-LAMBDA PCL::GENERATE-DISCRIMINATION-NET
-   PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION PCL::INVALID-QUALIFIERS
-   PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|
-   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
-   PCL::SET-CLASS-SLOT-VALUE-1 PCL::ACCESSOR-MISS
-   PCL::%INVALID-QUALIFIERS PCL::BOOTSTRAP-ACCESSOR-DEFINITION
-   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
-   PCL::|(FAST-METHOD NO-PRIMARY-METHOD (STANDARD-GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
-   PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
-   PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
-   PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CACHING PCL::EMIT-CHECKING)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::GET-ACCESSOR-METHOD-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION))
-     &REST T)
-    (VALUES &REST T))
-   PCL::MAP-ALL-CLASSES)) 
+   (FUNCTION ((T) (T) (T)) (VALUES &REST T))
+   SETF::|PCL::SLOT-ACCESSOR-STD-P| SETF::|PCL::SLOT-ACCESSOR-FUNCTION|
+   SETF::|PCL::CLASS-SLOT-VALUE| SETF::|COMMON-LISP::DOCUMENTATION|
+   WALKER::WALK-LET-IF WALKER::WALK-FORM-INTERNAL
+   WALKER::WALK-MULTIPLE-VALUE-SETQ ITERATE::WALK-GATHERING-BODY
+   ITERATE::RENAME-VARIABLES PCL:FIND-METHOD-COMBINATION
+   PCL:SLOT-MAKUNBOUND-USING-CLASS PCL:COMPUTE-EFFECTIVE-METHOD
+   PCL:SLOT-BOUNDP-USING-CLASS PCL:SLOT-VALUE-USING-CLASS
+   PCL::COMPUTE-SLOT-ACCESSOR-INFO PCL::CONSTANT-VALUE-MISS
+   PCL::GET-CLASS-SLOT-VALUE-1 PCL::CHECKING-MISS
+   PCL::ADD-WRITER-METHOD PCL::CONVERT-METHODS
+   PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P
+   PCL::SLOT-BOUNDP-USING-CLASS-DFUN PCL::ADD-BOUNDP-METHOD
+   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
+   PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS
+   PCL::ADD-READER-METHOD PCL::PRINT-STD-INSTANCE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES &REST T))
+   WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1
+   PCL::MAKE-SHORT-METHOD-COMBINATION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T)
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (NULL))
-   PCL::MAP-ALL-ORDERS)) 
+    ((T) (T) (T) (T))
+    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    NIL
+    ((T) (T) (T))
     (VALUES
      &OPTIONAL
      (OR
@@ -1610,290 +2042,391 @@
       (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
       (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
      (NULL)))
-   PCL::EMIT-N-N-WRITERS PCL::EMIT-N-N-READERS)) 
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER PCL::EMIT-READER/WRITER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::METHOD-CALL)) (T))
-   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T))
+    (NULL))
+   PCL::%CHECK-CNM-ARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
+   (FUNCTION ((T) (T) (T)) (NULL)) PCL::PRINT-CACHE
+   PCL::NOTE-PV-TABLE-REFERENCE PCL::FIX-SLOT-ACCESSORS
+   PCL::CHECK-METHOD-ARG-INFO
+   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
+   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS*)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (VALUES &REST T))
+   PCL::MAKE-A-METHOD PCL::REAL-MAKE-A-METHOD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
+    ((T))
+    (VALUES
+     (INTEGER 0 *) (INTEGER 0 *) (OR (SYSTEM:TRUE) (NULL))
+     (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::ANALYZE-LAMBDA-LIST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
     (OR
      (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
      (NULL)))
-   PCL::PRECOMPUTE-EFFECTIVE-METHODS)) 
+   WALKER::WALK-BINDINGS-2)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (OR (MEMBER "is not a non-null atom") (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|)) 
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:TRUE))
+   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T)
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (T))
-   PCL::SORT-METHODS)) 
+    ((T) (T))
+    (OR
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))
+     (MEMBER NIL)))
+   PCL::METHODS-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
-    (INTEGER 0 9223372036854775807))
-   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
+    ((T) (T) (T) (T))
+    (OR
+     (OR
+      (MEMBER "is not a symbol and so cannot be bound")
+      (MEMBER "is a keyword and so cannot be bound")
+      (MEMBER "is a constant and so cannot be bound")
+      (MEMBER "cannot be bound"))
+     (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
-   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
-   PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::ACCESSOR-VALUES1 PCL::ACCESSOR-VALUES-INTERNAL)) 
+   (FUNCTION
+    ((STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::COPY-ACCESSOR-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::LIST-DFUN)) 
+    ((T) (T) (T) (T))
+    (OR (MEMBER "is not a non-null atom") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (T))
-   PCL::LOAD-DEFMETHOD)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHING)) (T)) PCL::CACHING-CACHE)) 
+   (FUNCTION NIL (T)) PCL::%%ALLOCATE-INSTANCE--CLASS
+   PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
+   PCL::GET-EFFECTIVE-METHOD-GENSYM PCL::IN-THE-COMPILER-P
+   PCL::BOOTSTRAP-META-BRAID PCL::LIST-ALL-DFUNS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EXPAND-DEFMETHOD)) 
+   (FUNCTION ((T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   ITERATE::OPTIMIZE-GATHERING-FORM PCL::COMPUTE-PRECEDENCE
+   PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
+   PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
+   PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHE)) (T)) PCL::CACHE-OWNER)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
+   PCL::CHECK-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
+   (FUNCTION
+    ((STRUCTURE PCL::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
+   PCL::COPY-NO-METHODS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::CONSTANT-VALUE-DFUN-INFO)) 
+   (FUNCTION
+    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
+   PCL::POWER-OF-TWO-CEILING)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) (T) (T) (T) (T) (T)) NIL)
    PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
+   (FUNCTION ((T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   ITERATE::VARIABLES-FROM-LET PCL:EXTRACT-SPECIALIZER-NAMES
+   PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::EARLY-COLLECT-CPL
+   PCL::FORMAT-CYCLE-REASONS PCL::EXTRACT-PARAMETERS
+   PCL::EXTRACT-REQUIRED-PARAMETERS PCL::UNPARSE-SPECIALIZERS
+   PCL::COMPUTE-CLASS-SLOTS PCL::DEFAULT-CONSTANT-CONVERTER
+   PCL::SORT-SLOTS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) (T) &REST T)
     (VALUES
-     &OPTIONAL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     &OPTIONAL
+     (OR
+      (SYSTEM:HASH-TABLE-EQUALP) (SYSTEM:HASH-TABLE-EQL)
+      (SYSTEM:HASH-TABLE-EQ) (SYSTEM:HASH-TABLE-EQUAL) (MEMBER NIL))
+     (T) (T) (T) (OR (INTEGER 0 9223372036854775807) (MEMBER NIL))
      (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (OR (SYSTEM:TRUE) (NULL))) PCL::EARLY-GF-P
-   PCL::METHOD-CALL-P PCL::ONE-INDEX-P PCL::STD-INSTANCE-P PCL::N-N-P
-   PCL::LEGAL-CLASS-NAME-P PCL::TWO-CLASS-P PCL::INITIALIZE-INFO-P
-   PCL::ONE-CLASS-P PCL::DISPATCH-P PCL::DEFAULT-STRUCTUREP
-   PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::DEFAULT-CONSTANTP
-   PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::STRUCTURE-TYPE-P
-   PCL::NO-METHODS-P PCL::CONSTANT-VALUE-P
-   PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P PCL::CACHING-P PCL::GBOUNDP
-   PCL::INITIAL-P PCL::DNET-METHODS-P PCL::FAST-METHOD-CALL-P
-   PCL::CCLOSUREP PCL::EARLY-METHOD-STANDARD-ACCESSOR-P
-   PCL::FUNCALLABLE-INSTANCE-P PCL::FIELD-TYPE-SIMPLE-TYPEP-FN
-   PCL::ONE-INDEX-DFUN-INFO-P PCL::UPDATE-C-A-M-GF-INFO PCL::CHECKING-P
-   PCL::COMPLICATED-INSTANCE-CREATION-METHOD PCL::INITIAL-DISPATCH-P
-   PCL::ARG-INFO-P PCL::DEFAULT-METHOD-ONLY-P PCL::STRUCTURE-OBJECT-P
-   PCL::PV-TABLEP PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS PCL::CACHE-P
-   PCL::%FBOUNDP PCL::STRUCTURE-INSTANCE-P
-   PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::ACCESSOR-DFUN-INFO-P
-   PCL::ARG-INFO-VALID-P PCL::FAST-INSTANCE-BOUNDP-P PCL::DFUN-INFO-P)) 
+   PCL::MAKE-ACCESSOR-TABLE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION (&REST T) (STRUCTURE PCL::DISPATCH))
    PCL::|__si::MAKE-DISPATCH|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::PV-TABLE))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::PV-TABLE-PV-SIZE)) 
+   (FUNCTION (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::STRING-APPEND)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T)
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION))
+    ((T)
      (OR
+      (BROADCAST-STREAM) (CONCATENATED-STREAM) (ECHO-STREAM)
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION))
-     (OR
+       (SYSTEM:FILE-INPUT-STREAM) (SYSTEM:FILE-OUTPUT-STREAM)
+       (SYSTEM:FILE-IO-STREAM) (SYSTEM:FILE-PROBE-STREAM))
+      (OR (SYSTEM:STRING-INPUT-STREAM) (SYSTEM:STRING-OUTPUT-STREAM))
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (VALUES &REST T))
-   PCL::GENERATE-DISCRIMINATION-NET-INTERNAL)) 
+       (SYSTEM::FILE-SYNONYM-STREAM) (SYSTEM::NON-FILE-SYNONYM-STREAM))
+      (TWO-WAY-STREAM))
+     (T))
+    (NULL))
+   PCL::PRINT-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
-     (T))
-    (VALUES &REST T))
-   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|)) 
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (STRUCTURE PCL::CHECKING))
+   PCL::COPY-CHECKING)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (OR
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::CHECKING))
-      (MEMBER NIL))))
-   PCL::MAKE-CHECKING-DFUN)) 
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::ONE-INDEX-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::CHECK-INITARGS-2-PLIST PCL::CHECK-INITARGS-2-LIST
-   PCL::CHECK-INITARGS-1)) 
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
+   PCL::ACCESSOR-VALUES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (NULL))
+   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+   PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::CONSTANT-VALUE-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (MEMBER #())) PCL::COMPUTE-CALLS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
+    ((T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-TAGBODY WALKER::WALK-TAGBODY-1 WALKER::WALK-LABELS
+   WALKER::WALK-FLET WALKER::RECONS WALKER:VARIABLE-DECLARATION
+   PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| 
+   PCL::CAN-OPTIMIZE-ACCESS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
-   PCL::CACHE-MISS-VALUES-INTERNAL)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-EMF-CALL-METHOD
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
+   PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 PCL::OPTIMIZE-ACCESSOR-CALL
+   PCL::REAL-MAKE-METHOD-INITARGS-FORM)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (T))
-   PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
-   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
-   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-EMF-CACHE
-   PCL::UPDATE-SLOTS-IN-PV
-   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
-   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-   PCL::LOAD-FUNCTION-GENERATOR PCL::COMPUTE-PV-SLOT)) 
+   (FUNCTION
+    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::CHECK-INITARGS-VALUES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (VALUES (T) (T) (T)))
+   PCL::PARSE-METHOD-OR-SPEC)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
-   PCL::SYMBOL-OR-CONS-LESSP)) 
+    ((T) (T))
+    (VALUES
+     (OR
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
+   PCL::N-N-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
+   PCL::%STD-INSTANCE-WRAPPER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T))
     (VALUES
-     &OPTIONAL (T) (T) (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   ITERATE::EXPAND-INTO-LET)) 
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EXPAND-SHORT-DEFCOMBIN PCL::EXPAND-LONG-DEFCOMBIN
-   PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST PCL::GET-SETF-FUNCTION-NAME
-   PCL::MAKE-PV-TYPE-DECLARATION PCL::COMPUTE-MCASE-PARAMETERS
-   PCL::MAKE-PV-TABLE-TYPE-DECLARATION PCL::MAKE-CALL-METHODS
-   PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD
-   PCL::MAKE-CALLS-TYPE-DECLARATION)) 
+   (FUNCTION
+    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
+    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::COMPUTE-STD-CPL-PHASE-3)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (VALUES
-     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
-     (T)))
-   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
+    ((T) (T) (T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES &REST T))
-   WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1
-   PCL::MAKE-SHORT-METHOD-COMBINATION)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
+   PCL::|__si::MAKE-ONE-INDEX|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
-   PCL::NEXT-WRAPPER-FIELD)) 
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::PV-TABLE-SLOT-NAME-LISTS PCL::PV-TABLE-CALL-LIST)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
-   PCL::ACCESSOR-VALUES)) 
+   (FUNCTION
+    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
+   PCL::COPY-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
+   PCL::SYMBOL-LESSP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::MAKE-FAST-INSTANCE-BOUNDP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
-    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
-   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL)) 
+    ((T) (T) (T))
+    (VALUES
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (NULL)))
+   PCL::GENERATING-LISP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::INITIALIZE-INFO))
-    (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::COPY-INITIALIZE-INFO)) 
+    ((T) (T) (T) (INTEGER 0 9223372036854775807))
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::FILL-CACHE-FROM-CACHE-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
-   ITERATE::VARIABLE-SAME-P PCL::SKIP-FAST-SLOT-ACCESS-P
-   PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P PCL::ENTRY-IN-CACHE-P
-   PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|)) 
-(PROCLAIM '(FTYPE (FUNCTION (&REST T) (INTEGER 0 0)) PCL::ZERO)) 
+   (FUNCTION NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
-   PCL::COPY-ARG-INFO)) 
+   (FUNCTION
+    ((T))
+    (OR
+     (OR
+      (OR (INTEGER * *) (RATIO * *))
+      (OR (SHORT-FLOAT * *) (LONG-FLOAT * *)))
+     (OR
+      (SYSTEM:COMPLEX* (INTEGER * *) (RATIO * *))
+      (SYSTEM:COMPLEX* (RATIO * *) (INTEGER * *))
+      (SYSTEM:COMPLEX* (INTEGER * *) (INTEGER * *))
+      (SYSTEM:COMPLEX* (RATIO * *) (RATIO * *))
+      (SYSTEM:COMPLEX* (SHORT-FLOAT * *) (SHORT-FLOAT * *))
+      (SYSTEM:COMPLEX* (LONG-FLOAT * *) (LONG-FLOAT * *)))))
+   PCL::CACHING-DFUN-COST)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
-   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
-   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION
+    ((T) (T))
+    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::FORM-LIST-TO-LISP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::INITIAL)) (STRUCTURE PCL::INITIAL))
-   PCL::COPY-INITIAL)) 
+   (FUNCTION ((T) (T) &REST T) (VALUES &REST T))
+   PCL:ENSURE-CLASS-USING-CLASS PCL:ENSURE-GENERIC-FUNCTION-USING-CLASS
+   PCL:WRITER-METHOD-CLASS SHARED-INITIALIZE NO-NEXT-METHOD
+   CHANGE-CLASS UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
+   PCL:READER-METHOD-CLASS PCL::SLOT-VALUE-OR-DEFAULT
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION
+   PCL::GET-EFFECTIVE-METHOD-FUNCTION
+   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION WALKER:NESTED-WALK-FORM
+   PCL::SYMBOL-APPEND PCL::LOAD-DEFGENERIC)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
-   PCL::COPY-N-N)) 
+   (FUNCTION (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
+   PCL::FALSE)) 
 (PROCLAIM
- '(FTYPE (FUNCTION NIL (STRUCTURE PCL::ARG-INFO)) PCL::MAKE-ARG-INFO)) 
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((STRUCTURE PCL::INITIALIZE-INFO)) (T))
@@ -1913,39 +2446,94 @@
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     &REST T)
     (VALUES
+     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MUTATE-SLOTS-AND-CALLS PCL::SLOT-NAME-LISTS-FROM-SLOTS)) 
+   PCL::PARSE-SPECIALIZED-LAMBDA-LIST)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     &OPTIONAL (SYSTEM:PROPER-CONS (T) (T))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::FORM-LIST-TO-LISP)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EARLY-ACCESSOR PCL::MAKE-UNORDERED-METHODS-EMF
+   PCL::ACCESSOR-MISS-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (T)) WALKER::RELIST WALKER::RELIST*
+   FIND-CLASS PCL::ALLOCATE-STRUCTURE-INSTANCE
+   PCL::ALLOCATE-STANDARD-INSTANCE PCL::EARLY-FIND-CLASS-SYMBOL
+   PCL::INITIALIZE-METHOD-FUNCTION PCL::MAKE-FINAL-DFUN
+   PCL::MAKE-SPECIALIZABLE PCL::FIND-CLASS-CELL
+   PCL::FIND-CLASS-PREDICATE PCL::UPDATE-DFUN PCL::TRACE-METHOD
+   PCL::SET-DFUN PCL::EARLY-METHOD-SPECIALIZERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (T)) SETF::|COMMON-LISP::FIND-CLASS|
+   WALKER::CONVERT-MACRO-TO-LAMBDA PCL::MAKE-EMF-FROM-METHOD
+   PCL::PROBE-CACHE PCL::GET-EFFECTIVE-METHOD-FUNCTION1
+   PCL::GET-METHOD-FUNCTION-PV-CELL
+   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::METHOD-FUNCTION-GET
+   PCL::REAL-ADD-METHOD PCL::GET-DECLARATION
+   PCL::FIND-CLASS-PREDICATE-FROM-CELL PCL::FIND-CLASS-FROM-CELL
+   PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
+   PCL::REAL-ENSURE-GF-USING-CLASS--NULL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
+    ((STRUCTURE PCL::CACHE))
     (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::CACHE-OVERFLOW)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
+   PCL::COPY-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL
      (OR
-      (OR (INTEGER * *) (RATIO * *))
-      (OR (SHORT-FLOAT * *) (LONG-FLOAT * *)))
-     (OR
-      (SYSTEM:COMPLEX* (INTEGER * *) (RATIO * *))
-      (SYSTEM:COMPLEX* (RATIO * *) (INTEGER * *))
-      (SYSTEM:COMPLEX* (INTEGER * *) (INTEGER * *))
-      (SYSTEM:COMPLEX* (RATIO * *) (RATIO * *))
-      (SYSTEM:COMPLEX* (SHORT-FLOAT * *) (SHORT-FLOAT * *))
-      (SYSTEM:COMPLEX* (LONG-FLOAT * *) (LONG-FLOAT * *)))))
-   PCL::CACHING-DFUN-COST)) 
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPILE-LAMBDA)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::PV-TABLE))
-   PCL::MAKE-PV-TABLE-INTERNAL)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -1975,1414 +2563,965 @@
    PCL::EARLY-COLLECT-INHERITANCE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
-   PCL::COPY-CACHING)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CHECKING-OR-CACHING)) 
-(PROCLAIM
- '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::FAST-METHOD-CALL))
-    (STRUCTURE PCL::FAST-METHOD-CALL))
-   PCL::COPY-FAST-METHOD-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 268435455)) PCL::EARLY-CLASS-SIZE
-   PCL::ARG-INFO-NKEYS PCL::ARG-INFO-NUMBER-REQUIRED)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T))
-    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-CONSTANT-VALUE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::PARSE-QUALIFIER-PATTERN)) 
+    ((T) (T))
+    (VALUES
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
+   PCL::*SUBTYPEP PCL::SAUT-CLASS-EQ PCL::SAUT-EQL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
-   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
+   (FUNCTION ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
+   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
-(PROCLAIM
- '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
+   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (SYSTEM:TRUE))
+   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
-   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
-   PCL::SET-ARG-INFO)) 
+   (FUNCTION ((T)) (NOT (MEMBER NIL))) PCL::EARLY-CLASS-DEFINITION
+   PCL::GET-PV-CELL-FOR-CLASS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
-     (T))
+    ((T) (T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
     (VALUES &REST T))
-   PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (OR
-     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
-     (MEMBER T)))
-   PCL::OPTIMIZE-SLOT-BOUNDP PCL::OPTIMIZE-SLOT-VALUE
-   PCL::OPTIMIZE-SET-SLOT-VALUE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (T))
-   PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE
-   PCL::GF-INFO-C-A-M-EMF-STD-P PCL::ARG-INFO-LAMBDA-LIST
-   PCL::GF-INFO-FAST-MF-P PCL::GF-INFO-STATIC-C-A-M-EMF
-   PCL::ARG-INFO-NUMBER-OPTIONAL PCL::ARG-INFO-METATYPES
-   PCL::ARG-INFO-KEYWORDS PCL::ARG-INFO-PRECEDENCE
-   PCL::ARG-INFO-KEY/REST-P)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (VALUES &REST T))
-   SETF::|PCL::SLOT-ACCESSOR-STD-P| SETF::|PCL::SLOT-ACCESSOR-FUNCTION|
-   SETF::|PCL::CLASS-SLOT-VALUE| SETF::|COMMON-LISP::DOCUMENTATION|
-   WALKER::WALK-LET-IF WALKER::WALK-FORM-INTERNAL
-   WALKER::WALK-MULTIPLE-VALUE-SETQ ITERATE::WALK-GATHERING-BODY
-   ITERATE::RENAME-VARIABLES PCL:FIND-METHOD-COMBINATION
-   PCL:SLOT-MAKUNBOUND-USING-CLASS PCL:COMPUTE-EFFECTIVE-METHOD
-   PCL:SLOT-BOUNDP-USING-CLASS PCL:SLOT-VALUE-USING-CLASS
-   PCL::COMPUTE-SLOT-ACCESSOR-INFO PCL::CONSTANT-VALUE-MISS
-   PCL::GET-CLASS-SLOT-VALUE-1 PCL::CHECKING-MISS
-   PCL::ADD-WRITER-METHOD PCL::CONVERT-METHODS
-   PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P
-   PCL::SLOT-BOUNDP-USING-CLASS-DFUN PCL::ADD-BOUNDP-METHOD
-   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
-   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
-   PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
-   PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
-   PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
-   PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
-   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
-   PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS
-   PCL::ADD-READER-METHOD PCL::PRINT-STD-INSTANCE)) 
+   PCL::ORDER-SPECIALIZERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::|__si::MAKE-CONSTANT-VALUE|)) 
-(PROCLAIM '(FTYPE (FUNCTION NIL (VALUES)) PCL::COUNT-ALL-DFUNS)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::MAKE-FAST-METHOD-CALL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   WALKER::WALK-REPEAT-EVAL PCL::COMPUTE-STD-CPL)) 
+    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
-    (VALUES
-     &OPTIONAL
+    ((T) (T)
      (OR
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
-     (NULL)))
-   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER PCL::GENERATING-LISP
-   PCL::EMIT-READER/WRITER)) 
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (NULL))
+   PCL::MAP-ALL-ORDERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) &REST T) (VALUES (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
-   PCL::GET-METHOD-FUNCTION)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
+   PCL::|__si::MAKE-DFUN-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION ((T)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
+   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-DLAP)) 
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CHECKING)) (T)) PCL::CHECKING-CACHE
-   PCL::CHECKING-FUNCTION)) 
+   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T)) (OR (SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY T *)))
-   PCL::ALLOCATE-CACHE-VECTOR)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
-   PCL::COMPUTE-LINE-SIZE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::INITIALIZE-INFO)) 
+    ((T) (T) (T) (T))
+    (OR
+     (OR
+      (OR
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
-   PCL::EXPAND-CACHE)) 
-(PROCLAIM '(FTYPE (FUNCTION (&REST T) (SYSTEM:TRUE)) PCL::TRUE)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::COPY-ONE-INDEX)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::NO-METHODS))
-   PCL::NO-METHODS-DFUN-INFO)) 
+   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (T))
+   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
-   PCL::COPY-METHOD-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
-   PCL::%STD-INSTANCE-WRAPPER)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T) (T) &REST T) (T)) PCL::REAL-GET-METHOD)) 
+    ((T) (T) (T) (T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::OPTIMIZE-GF-CALL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
-   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
+   (FUNCTION NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::METHOD-CALL))
-   PCL::MAKE-METHOD-CALL)) 
+   (FUNCTION NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
+   (FUNCTION ((T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL:SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
+   (FUNCTION ((T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   WALKER::VARIABLE-SYMBOL-MACRO-P PCL::REMTAIL PCL::%SET-CCLOSURE
+   PCL::MAKE-DLAP-LAMBDA-LIST PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST
+   PCL::MAKE-DFUN-LAMBDA-LIST PCL::MAKE-PLIST PCL::DEFAULT-INITARGS-1
+   PCL::MEC-ALL-CLASSES PCL::DESTRUCTURE-INTERNAL
+   PCL::CLASS-CAN-PRECEDE-P WALKER:VARIABLE-LEXICAL-P
+   PCL::MEC-ALL-CLASS-LISTS PCL::NET-CONSTANT-CONVERTER
+   PCL::MEMF-CONSTANT-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::CHECK-INITARGS-VALUES)) 
+    ((T) &REST T)
+    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
+   MAKE-LOAD-FORM-SAVING-SLOTS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
+   PCL::|__si::MAKE-NO-METHODS|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
-   PCL::COPY-DFUN-INFO)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
+   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
+   PCL::CACHE-SIZE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
+    ((T) (T) (T) (T))
     (VALUES
-     &OPTIONAL (T) (T)
+     (T)
      (OR
-      (OR
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::CACHING))
-      (MEMBER NIL))))
-   PCL::MAKE-CACHING-DFUN)) 
+      (SYSTEM::NON-SIMPLE-ARRAY T *) (SIMPLE-ARRAY T *) (MEMBER NIL))))
+   PCL::MAKE-SHARED-INITIALIZE-FORM-LIST)) 
 (PROCLAIM
- '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
+ '(FTYPE
+   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
+   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
+    ((T) (T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
-   PCL::SYMBOL-LESSP)) 
+   (FUNCTION
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (VALUES (T) (T)))
-   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
-   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS)) 
+   (FUNCTION ((T) &REST T) (NULL)) ITERATE::MAYBE-WARN
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (T)) PCL::TWO-CLASS-CACHE
-   PCL::TWO-CLASS-INDEX PCL::TWO-CLASS-WRAPPER1 PCL::TWO-CLASS-WRAPPER0
-   PCL::TWO-CLASS-ACCESSOR-TYPE)) 
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (MEMBER "a string or NULL") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T)) (T))
    PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T))
-    (VALUES
-     &OPTIONAL
-     (OR
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
-     (NULL)))
-   PCL::EMIT-ONE-CLASS-WRITER PCL::EMIT-ONE-CLASS-READER
-   PCL::EMIT-TWO-CLASS-WRITER PCL::EMIT-TWO-CLASS-READER
-   PCL::EMIT-ONE-INDEX-WRITERS PCL::EMIT-ONE-INDEX-READERS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
-   PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::SAUT-CLASS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
+   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (VALUES &REST T))
-   SETF::|PCL::GENERIC-FUNCTION-DECLARATIONS|
-   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL OWNER slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SLOTS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PLIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot READER|
-   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITFORM slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL METHODS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER DEF slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL METHODS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER DEF slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INITARGS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot READER|
-   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INDEX slot READER|
-   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INDEX slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot READER|
-   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot READER|
-   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL LOCATION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL FIELD slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER NAME slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL FIELD slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot READER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER NAME slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL PLIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot READER|
-   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PLIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INITFORM slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITFORM slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITARGS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INITARGS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL LOCATION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot READER|
-   SLOT-ACCESSOR-NAME::|PCL LOCATION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRITERS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL NLINES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SOURCE slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL NLINES slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SIZE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SIZE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL NAME slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot READER|
-   SLOT-ACCESSOR-NAME::|PCL NKEYS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL VALUEP slot READER|
-   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL NKEYS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL VALUEP slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot READER|
-   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL KEY slot READER|
-   SLOT-ACCESSOR-NAME::|PCL KEY slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot READER|
-   SLOT-ACCESSOR-NAME::|PCL READERS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRITERS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL WRITERS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SLOTS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL SOURCE slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SOURCE slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL CACHE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL METHODS slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL PORT slot READER|
-   SLOT-ACCESSOR-NAME::|PCL PORT slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL NAME slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot READER|
-   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot READER|
-   SLOT-ACCESSOR-NAME::|PCL NAME slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot READER|
-   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot READER|
-   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot READER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot READER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot READER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot READER|
-   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot READER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot WRITER|
-   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot BOUNDP|
-   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot READER|
-   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL READERS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot READER|
-   SLOT-ACCESSOR-NAME::|PCL MASK slot READER|
-   SLOT-ACCESSOR-NAME::|PCL READERS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL MASK slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot READER|
-   SLOT-ACCESSOR-NAME::|PCL OWNER slot READER|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot READER|
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot READER| NO-APPLICABLE-METHOD
-   PCL:UPDATE-DEPENDENT SLOT-MISSING SLOT-UNBOUND
-   PCL:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER INVALID-METHOD-ERROR
-   METHOD-COMBINATION-ERROR PCL::REMOVE-NAMED-METHOD
-   PCL::|PCL::TRACED-METHOD class predicate| PCL::USE-PACKAGE-PCL
-   PCL::|COMMON-LISP::NULL class predicate|
-   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
-   PCL::|COMMON-LISP::SYMBOL class predicate|
-   PCL::|COMMON-LISP::CHARACTER class predicate|
-   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
-   PCL::|COMMON-LISP::STRING class predicate|
-   PCL::|COMMON-LISP::VECTOR class predicate|
-   PCL::|COMMON-LISP::ARRAY class predicate|
-   PCL::|COMMON-LISP::STREAM class predicate|
-   PCL::|COMMON-LISP::FILE-STREAM class predicate|
-   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
-   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
-   PCL::|COMMON-LISP::STRING-STREAM class predicate|
-   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
-   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
-   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
-   PCL::|COMMON-LISP::HASH-TABLE class predicate|
-   PCL::|COMMON-LISP::PACKAGE class predicate|
-   PCL::|COMMON-LISP::READTABLE class predicate|
-   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
-   PCL::|COMMON-LISP::PATHNAME class predicate|
-   PCL::|COMMON-LISP::CONS class predicate|
-   PCL::|COMMON-LISP::LIST class predicate|
-   PCL::|COMMON-LISP::SEQUENCE class predicate|
-   PCL::|COMMON-LISP::RATIO class predicate|
-   PCL::|COMMON-LISP::INTEGER class predicate|
-   PCL::|COMMON-LISP::RATIONAL class predicate|
-   PCL::|COMMON-LISP::REAL class predicate|
-   PCL::|COMMON-LISP::FLOAT class predicate|
-   PCL::|COMMON-LISP::COMPLEX class predicate|
-   PCL::|COMMON-LISP::NUMBER class predicate|
-   PCL::|COMMON-LISP::T class predicate|
-   PCL::|COMMON-LISP::FUNCTION class predicate|
-   PCL::|COMMON-LISP::STRUCTURE-OBJECT class predicate|
-   PCL::|COMMON-LISP::STANDARD-OBJECT class predicate|
-   PCL::|COMMON-LISP::BUILT-IN-CLASS class predicate|
-   PCL::|PCL::SPECIALIZER-WITH-OBJECT class predicate|
-   PCL::|PCL::MODULE class predicate|
-   PCL::|PCL::ONE-INDEX-DFUN-INFO class predicate|
-   PCL::|PCL::DOCUMENTATION-MIXIN class predicate|
-   PCL::|PCL::ONE-CLASS class predicate|
-   PCL::|PCL::SLOT-OBJECT class predicate|
-   PCL::|PCL::INITIALIZE-INFO class predicate|
-   PCL::|PCL::CACHE class predicate|
-   PCL::|PCL::SLOT-DEFINITION class predicate|
-   PCL::|PCL::DIRECT-SLOT-DEFINITION class predicate|
-   PCL::|SYSTEM::S-DATA class predicate|
-   PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE
-   PCL::|PCL::PLIST-MIXIN class predicate|
-   PCL::|PCL::CLASS-PRECEDENCE-DESCRIPTION class predicate|
-   PCL::|PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate|
-   PCL::|PCL::TWO-CLASS class predicate|
-   PCL::|PCL::CHECKING class predicate|
-   PCL::|PCL::DFUN-INFO class predicate|
-   PCL::|COMPILER::FN class predicate|
-   PCL::|PCL::EFFECTIVE-SLOT-DEFINITION class predicate|
-   PCL::|PCL::STRUCTURE-SLOT-DEFINITION class predicate|
-   PCL::|PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
-   PCL::|PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
-   PCL::|PCL::FUNCALLABLE-STANDARD-OBJECT class predicate|
-   PCL::|PCL::METHOD-CALL class predicate|
-   PCL::|PCL::METAOBJECT class predicate|
-   PCL::|PCL::DEPENDENT-UPDATE-MIXIN class predicate|
-   PCL::|PCL::DEFINITION-SOURCE-MIXIN class predicate|
-   PCL::ARG-INFO-READER PCL::UPDATE-CONSTRUCTORS
-   PCL::|PCL::STD-CLASS class predicate|
-   PCL::|PCL::PCL-CLASS class predicate|
-   PCL::|PCL::ACCESSOR-DFUN-INFO class predicate|
-   PCL::COMPATIBLE-META-CLASS-CHANGE-P
-   PCL::|PCL::FAST-METHOD-CALL class predicate|
-   PCL::|PCL::STANDARD-SLOT-DEFINITION class predicate|
-   PCL::|PCL::STANDARD-DIRECT-SLOT-DEFINITION class predicate|
-   PCL::|PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
-   PCL::|PCL::STANDARD-METHOD-COMBINATION class predicate|
-   PCL::|PCL::FAST-INSTANCE-BOUNDP class predicate|
-   PCL::|PCL::ARG-INFO class predicate|
-   PCL::|PCL::PV-TABLE class predicate|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::TWO-CLASS))
+   PCL::|__si::MAKE-TWO-CLASS|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-LOAD-FORM (CLASS))| PCL::EXPAND-DEFCLASS)) 
+   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
+   PCL::BOOTSTRAP-SLOT-INDEX)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    (&REST T)
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::MAKE-PROGN)) 
+   (FUNCTION ((STRUCTURE PCL::INITIAL-DISPATCH)) (T))
+   PCL::INITIAL-DISPATCH-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-INDEX))
-   PCL::ONE-INDEX-DFUN-INFO)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
+   PCL::|__si::MAKE-CACHING|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
+   (FUNCTION ((T) (T) (T) (T) &REST T) (T)) PCL::ADD-NAMED-METHOD
+   PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) &REST T)
+    ((T) &REST T)
     (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (SYSTEM:PROPER-CONS (T) (T))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   ITERATE::RENAME-LET-BINDINGS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) 
+   PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((INTEGER 0 9223372036854775807) (T) (T))
     (VALUES
-     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
-   ITERATE::PARSE-DECLARATIONS)) 
+     (INTEGER 0 9223372036854775807) (INTEGER 0 9223372036854775807)
+     (INTEGER 1 4611686018427387904) (INTEGER 0 9223372036854775807)))
+   PCL::COMPUTE-CACHE-PARAMETERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (STRUCTURE) (T)) (VALUES &REST T))
-   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION
+    ((STRUCTURE PCL::INITIAL-DISPATCH))
+    (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::COPY-INITIAL-DISPATCH)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
+   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
+   PCL::COPY-ARG-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR
-     (OR
-      (OR
-       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-       (SIMPLE-ARRAY BIT (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-       (SIMPLE-ARRAY SHORT-FLOAT (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-       (SIMPLE-ARRAY FIXNUM (*)))
-      (OR
-       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::SORT-CALLS PCL::METHOD-LL->GENERIC-FUNCTION-LL)) 
+    ((STRUCTURE PCL::INITIALIZE-INFO))
+    (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::COPY-INITIALIZE-INFO)) 
+(PROCLAIM '(FTYPE (FUNCTION (&REST T) (INTEGER 0 0)) PCL::ZERO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (SYSTEM:TRUE))
-   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) NIL)
+   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   ITERATE::VARIABLES-FROM-LET PCL:EXTRACT-SPECIALIZER-NAMES
-   PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::EARLY-COLLECT-CPL
-   PCL::FORMAT-CYCLE-REASONS PCL::EXTRACT-PARAMETERS
-   PCL::EXTRACT-REQUIRED-PARAMETERS PCL::UNPARSE-SPECIALIZERS
-   PCL::COMPUTE-CLASS-SLOTS PCL::DEFAULT-CONSTANT-CONVERTER
-   PCL::SORT-SLOTS)) 
+   (FUNCTION
+    ((T))
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
-   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) 
+   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
+   ITERATE::SEQUENCE-ACCESSOR)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::METHOD-CALL))
-    (OR
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
      (OR
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-     (SYSTEM:INTERPRETED-FUNCTION)))
-   PCL::METHOD-CALL-FUNCTION)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (NOT (MEMBER NIL))) PCL::PV-TABLE-LOOKUP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-EARLY-ACCESSOR PCL::MAKE-UNORDERED-METHODS-EMF
-   PCL::ACCESSOR-MISS-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
+      (OR
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING))
+      (MEMBER NIL))))
+   PCL::MAKE-CACHING-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
-   PCL::COPY-DISPATCH)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES))
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|)) 
+(PROCLAIM '(FTYPE (FUNCTION (&REST T) (SYSTEM:TRUE)) PCL::TRUE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (VALUES &REST T))
-   WALKER::WALK-DECLARATIONS FIND-METHOD PCL::GET-METHOD
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (NULL))
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
-   PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1
-   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
-   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
+   (FUNCTION
+    ((T))
+    (VALUES
+     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
+     (T)))
+   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (OR (MEMBER "a function") (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|)) 
+ '(FTYPE (FUNCTION ((T) (T)) (STRUCTURE PCL::N-N)) PCL::N-N-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
-   PCL::|__si::MAKE-NO-METHODS|)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM
+   PCL::MAKE-DEFMETHOD-FORM-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) (T))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   PCL::OPTIMIZE-GF-CALL)) 
+   (FUNCTION ((T)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
+   PCL::NEXT-WRAPPER-FIELD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((INTEGER 0 9223372036854775807) (T) &REST T)
-    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::FIND-FREE-CACHE-LINE)) 
+   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (VALUES &REST T))
-   PCL:ENSURE-CLASS-USING-CLASS PCL:ENSURE-GENERIC-FUNCTION-USING-CLASS
-   PCL:WRITER-METHOD-CLASS SHARED-INITIALIZE NO-NEXT-METHOD
-   CHANGE-CLASS UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
-   PCL:READER-METHOD-CLASS PCL::SLOT-VALUE-OR-DEFAULT
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION
-   PCL::GET-EFFECTIVE-METHOD-FUNCTION
-   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION WALKER:NESTED-WALK-FORM
-   PCL::SYMBOL-APPEND PCL::LOAD-DEFGENERIC)) 
+   (FUNCTION ((T) &REST T) (VALUES &REST T)) ENSURE-GENERIC-FUNCTION
+   MAKE-INSTANCE REINITIALIZE-INSTANCE INITIALIZE-INSTANCE
+   ALLOCATE-INSTANCE PCL:ENSURE-CLASS MAKE-LOAD-FORM
+   PCL::CALL-NO-NEXT-METHOD PCL::DISPATCH-DFUN-COST
+   PCL::NO-PRIMARY-METHOD PCL::MAKE-TYPE-PREDICATE-NAME
+   WALKER:WALK-FORM PCL::MAKE-METHOD-FUNCTION-INTERNAL
+   PCL::MAKE-INSTANCE-1 PCL::COERCE-TO-CLASS
+   PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
+   PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T| 
+   PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
+   WALKER:MACROEXPAND-ALL
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION) T|
+   PCL::GET-DFUN-CONSTRUCTOR
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :NAME :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :INITFUNCTION :NAME :READERS :WRITERS :INITARGS :INITFORM) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :FUNCTION :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-EFFECTIVE-SLOT-DEFINITION (:DEFSTRUCT-ACCESSOR-SYMBOL :INTERNAL-READER-FUNCTION :INTERNAL-WRITER-FUNCTION :NAME :INITFORM :INITFUNCTION :INITARGS :ALLOCATION :TYPE :CLASS) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-DIRECT-SLOT-DEFINITION (:CLASS :NAME :DEFSTRUCT-ACCESSOR-SYMBOL :INTERNAL-READER-FUNCTION :INTERNAL-WRITER-FUNCTION :TYPE :INITFORM :INITFUNCTION) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-EFFECTIVE-SLOT-DEFINITION (:NAME :INITFORM :INITFUNCTION :INITARGS :ALLOCATION :TYPE :CLASS) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :NAME :READERS :WRITERS :INITARGS) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE :PREDICATE-NAME) NIL|
+   PCL::|MAKE-INSTANCE EQL-SPECIALIZER (:OBJECT) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION NIL NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS) NIL|
+   PCL::|MAKE-INSTANCE CLASS-EQ-SPECIALIZER (:CLASS) NIL|
+   PCL::GET-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T)
+    ((T) (T) &REST T)
+    (VALUES
+     (T)
      (OR
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (VALUES &REST T))
-   PCL::ORDER-SPECIALIZERS)) 
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))))
+   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
+   (FUNCTION ((T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
+   ITERATE::OPTIMIZE-ITERATE-FORM ITERATE::SIMPLE-EXPAND-GATHERING-FORM
+   ITERATE::RENAME-AND-CAPTURE-VARIABLES PCL::MAKE-METHOD-SPEC
+   PCL::EXPAND-DEFGENERIC PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
+   PCL::FIRST-FORM-TO-LISP PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
+   PCL::EMIT-BOUNDP-CHECK PCL::MAKE-TOP-LEVEL-FORM
+   PCL::EMIT-SLOT-READ-FORM PCL::EMIT-1-T-DLAP PCL::MAKE-DFUN-CALL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
-   PCL::MAKE-N-N-ACCESSOR-DFUN)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (T))
+   PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
+   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-EMF-CACHE
+   PCL::UPDATE-SLOTS-IN-PV
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
+   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::LOAD-FUNCTION-GENERATOR PCL::COMPUTE-PV-SLOT)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   ITERATE::OPTIMIZE-GATHERING-FORM PCL::COMPUTE-PRECEDENCE
-   PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
-   PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
-   PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
-   PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
-   PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|)) 
+   (FUNCTION ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
+   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
+    ((T) (T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
       (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (T))
-    (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION)) 
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
+       (STRUCTURE PCL::CHECKING))
+      (MEMBER NIL))))
+   PCL::MAKE-CHECKING-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (OR
-     (MEMBER
-      PCL:STANDARD-INSTANCE PCL::STRUCTURE-INSTANCE
-      PCL::BUILT-IN-INSTANCE PCL::SLOT-INSTANCE CLASS)
-     (MEMBER T)))
-   PCL::RAISE-METATYPE)) 
+   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
+   PCL::COMPUTE-LINE-SIZE)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (T)))
-   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   ITERATE::SIMPLE-EXPAND-ITERATE-FORM PCL::DEAL-WITH-ARGUMENTS-OPTION
-   PCL::MEC-ALL-CLASSES-INTERNAL PCL::MAKE-DFUN-ARG-LIST
-   PCL::CANONICALIZE-DEFCLASS-OPTION
-   PCL::CANONICALIZE-SLOT-SPECIFICATION
-   PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
-   PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
-   PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION PCL::EMIT-1-NIL-DLAP
-   PCL::MAKE-CAXR)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
+   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
+   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL))
-   PCL::|__si::MAKE-INITIAL|)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
+   PCL::CACHE-LINE-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-   PCL::COPY-ACCESSOR-DFUN-INFO)) 
+   (FUNCTION ((T) (T) (T) (T)) (OR (MEMBER "a function") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL)))
     (VALUES
-     (OR
-      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
-     (T)
+     (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
      (OR
       (OR
-       (OR
-        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-        (SIMPLE-ARRAY BIT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-        (SIMPLE-ARRAY SHORT-FLOAT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-        (SIMPLE-ARRAY FIXNUM (*)))
-       (OR
-        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-        (SYSTEM::NON-SIMPLE-ARRAY T *)
-        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
-   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|)) 
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))))
+   PCL::PARSE-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::SAUT-NOT)) 
+   (FUNCTION ((T) (T) (T)) (T)) SETF::|PCL::PLIST-VALUE|
+   SETF::|PCL::METHOD-FUNCTION-GET| WALKER::WALK-DO* WALKER::WALK-IF
+   WALKER::WALK-LAMBDA WALKER::WALK-COMPILER-LET
+   WALKER::RELIST-INTERNAL WALKER::WALK-SETQ WALKER::WALK-LET
+   WALKER::WALK-MULTIPLE-VALUE-BIND WALKER::WALK-LET*
+   WALKER::WALK-SYMBOL-MACROLET WALKER::WALK-PROG WALKER::WALK-PROG*
+   WALKER::WALK-DO WALKER::WALK-LOCALLY WALKER::WALK-MACROLET
+   WALKER::WALK-NAMED-LAMBDA WALKER::WALK-UNEXPECTED-DECLARE
+   PCL::CONVERT-TABLE PCL::OPTIMIZE-GF-CALL-INTERNAL
+   PCL::TRACE-EMF-CALL-INTERNAL PCL::SET-SLOT-VALUE
+   PCL::GET-FUNCTION-GENERATOR PCL::OBSOLETE-INSTANCE-TRAP
+   PCL::FLUSH-CACHE-TRAP PCL::SET-FUNCTION-NAME-1
+   PCL::DECLARE-STRUCTURE PCL::INVALIDATE-WRAPPER
+   PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
+   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
+   PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
+   PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
+   PCL::SET-SLOT-VALUE-NORMAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::CLASS-MIGHT-PRECEDE-P)) 
+    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (T)) PCL::ONE-INDEX-CACHE
+   PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::PV-TABLE))
-    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::PV-TABLE-CACHE)) 
+    ((T) (T) (T) (T))
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
+   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CACHE))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   PCL::CACHE-OVERFLOW)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
+   PCL::|__si::MAKE-PV-TABLE|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES &REST T))
-   PCL:COMPUTE-APPLICABLE-METHODS-USING-CLASSES PCL:MAP-DEPENDENTS
-   PCL:REMOVE-DIRECT-SUBCLASS PRINT-OBJECT
-   PCL:COMPUTE-EFFECTIVE-SLOT-DEFINITION PCL:REMOVE-DIRECT-METHOD
-   PCL:VALIDATE-SUPERCLASS PCL:ADD-DIRECT-SUBCLASS ADD-METHOD
-   PCL:ADD-DIRECT-METHOD PCL:ADD-DEPENDENT PCL:REMOVE-DEPENDENT
-   SLOT-VALUE PCL:EFFECTIVE-SLOT-DEFINITION-CLASS
-   PCL:DIRECT-SLOT-DEFINITION-CLASS REMOVE-METHOD
-   COMPUTE-APPLICABLE-METHODS DESCRIBE-OBJECT
-   PCL::LEGAL-DOCUMENTATION-P PCL::REMOVE-BOUNDP-METHOD
-   PCL::%NO-PRIMARY-METHOD PCL::LEGAL-SPECIALIZER-P
-   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
-   PCL::MAKE-DIRECT-SLOTD PCL::LEGAL-QUALIFIER-P PCL::CLASS-SLOT-VALUE
-   PCL::DEFAULT-INITARGS PCL::UPDATE-SLOT-VALUE-GF-INFO
-   PCL::LEGAL-SLOT-NAME-P PCL::COMPUTE-TEST PCL::SLOTS-TO-INSPECT
-   PCL::SAME-SPECIALIZER-P PCL::SDFUN-FOR-CACHING
-   PCL::LEGAL-METHOD-FUNCTION-P PCL::MAKE-READER-METHOD-FUNCTION
-   PCL::SLOT-ACCESSOR-FUNCTION PCL::SLOT-ACCESSOR-STD-P
-   PCL::LEGAL-SPECIALIZERS-P PCL::MAKE-WRITER-METHOD-FUNCTION
-   PCL::LEGAL-QUALIFIERS-P PCL::INVOKE-EMF
-   PCL::MAKE-BOUNDP-METHOD-FUNCTION PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS
-   DOCUMENTATION PCL::SLOT-VALUE-NORMAL
-   PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::REMOVE-WRITER-METHOD
-   PCL::UPDATE-GF-DFUN PCL::INITIAL-DFUN PCL::REMOVE-READER-METHOD)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::CACHE-VALUEP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (VALUES
-     (T)
-     (OR
-      (OR
-       (OR
-        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-        (SIMPLE-ARRAY BIT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-        (SIMPLE-ARRAY SHORT-FLOAT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-        (SIMPLE-ARRAY FIXNUM (*)))
-       (OR
-        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-        (SYSTEM::NON-SIMPLE-ARRAY T *)
-        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::EXTRACT-DECLARATIONS)) 
+    ((STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::COPY-DEFAULT-METHOD-ONLY)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
-   PCL::|__si::MAKE-STD-INSTANCE|)) 
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::PV-TABLE-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (VALUES
-     (OR
+    ((OR
       (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (INTEGER -9223372036854775807 9223372036854775807)))
-   PCL::COMPUTE-STD-CPL-PHASE-1)) 
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (NULL))
+   PCL::MAP-SPECIALIZERS PCL::MAP-ALL-GENERIC-FUNCTIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) &REST T) (VALUES &REST T))
-   UPDATE-INSTANCE-FOR-REDEFINED-CLASS
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1
-   PCL::EARLY-ADD-NAMED-METHOD)) 
+   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
+   PCL::COPY-DISPATCH)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1
-   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL)) 
+    ((T) (T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
+     (T))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
-   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
+   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
+   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-    (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION)) 
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::|__si::MAKE-ARG-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
+   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::TWO-CLASS-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (VALUES &REST T))
-   PCL::MAKE-A-METHOD PCL::REAL-MAKE-A-METHOD)) 
+   (FUNCTION NIL (STRUCTURE PCL::NO-METHODS))
+   PCL::NO-METHODS-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
-    (INTEGER 0 9223372036854775807))
-   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
+   (FUNCTION ((T)) (OR (INTEGER 0 12) (MEMBER NIL)))
+   PCL::WRAPPER-FIELD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
-   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
+    ((T) (T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (MEMBER NIL)
+      (OR
+       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)))))
+   PCL::MAKE-FINAL-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
+   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (NULL)) PCL::SHOW-EMF-CALL-TRACE PCL::RENEW-SYS-FILES
-   PCL::BOOTSTRAP-BUILT-IN-CLASSES PCL::SHOW-DFUN-CONSTRUCTORS
-   PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS)) 
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (T)))
+   PCL::GET-FUNCTION1)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
+    ((T))
     (OR
      (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
      (NULL)))
-   WALKER::WALK-BINDINGS-1 PCL::OPTIMIZE-GENERIC-FUNCTION-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-CLASS))
-   PCL::|__si::MAKE-ONE-CLASS|)) 
+   PCL:EXTRACT-LAMBDA-LIST PCL::GFS-OF-TYPE PCL::LIST-LARGE-CACHE
+   PCL::EARLY-COLLECT-SLOTS PCL::EXPAND-MAKE-INSTANCE-FORM
+   PCL::FIND-CYCLE-REASONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
-   PCL::INTERNED-SYMBOL-P)) 
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::INITIAL-DISPATCH)) (T))
-   PCL::INITIAL-DISPATCH-CACHE)) 
+ '(FTYPE (FUNCTION ((T) (T) (T) &REST T) (T)) PCL::REAL-GET-METHOD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T) (T))
     (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   WALKER::WALK-BINDINGS-2)) 
+     (MEMBER "is neither a class object nor an eql specializer")
+     (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EXPAND-EMF-CALL-METHOD
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
-   PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 PCL::OPTIMIZE-ACCESSOR-CALL
-   PCL::REAL-MAKE-METHOD-INITARGS-FORM)) 
+   (FUNCTION ((T)) (VALUES &REST T)) MAKE-INSTANCES-OBSOLETE
+   METHOD-QUALIFIERS PCL:METHOD-LAMBDA-LIST FUNCTION-KEYWORDS
+   PCL:SPECIALIZER-DIRECT-METHODS PCL:METHOD-SPECIALIZERS
+   PCL:SLOT-DEFINITION-ALLOCATION PCL:COMPUTE-CLASS-PRECEDENCE-LIST
+   PCL:CLASS-FINALIZED-P PCL:COMPUTE-DISCRIMINATING-FUNCTION
+   PCL:CLASS-DEFAULT-INITARGS PCL:CLASS-DIRECT-SLOTS
+   PCL:GENERIC-FUNCTION-LAMBDA-LIST PCL:FINALIZE-INHERITANCE
+   PCL:COMPUTE-SLOTS PCL:CLASS-SLOTS PCL:METHOD-FUNCTION
+   PCL:CLASS-PROTOTYPE PCL:CLASS-DIRECT-DEFAULT-INITARGS
+   PCL::INTERN-FUNCTION-NAME PCL::COMPILE-IIS-FUNCTIONS
+   PCL::|ARG-INFO SLOT10| PCL::MAKE-KEYWORD PCL::|PV-TABLE SLOT3|
+   PCL::|CHECKING SLOT1| PCL::|PV-TABLE SLOT2| PCL::SLOT-WRITER-SYMBOL
+   PCL::|PV-TABLE SLOT1|
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO
+   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::|PV-TABLE SLOT0|
+   PCL::|DFUN-INFO SLOT0|
+   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
+   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
+   PCL::|SYSTEM:S-DATA SLOT9| PCL::|SYSTEM:S-DATA SLOT8|
+   PCL::|SYSTEM:S-DATA SLOT7| PCL::|SYSTEM:S-DATA SLOT6|
+   PCL::|SYSTEM:S-DATA SLOT5| PCL::|SYSTEM:S-DATA SLOT4|
+   PCL::|SYSTEM:S-DATA SLOT3| PCL::COMPUTE-DEFAULT-INITARGS
+   PCL::|SYSTEM:S-DATA SLOT2| PCL::|SYSTEM:S-DATA SLOT1|
+   PCL::|SYSTEM:S-DATA SLOT0| PCL::DFUN-ARG-SYMBOL
+   PCL::CLASS-SLOT-CELLS PCL::SLOT-BOUNDP-SYMBOL
+   PCL::|METHOD-CALL SLOT1| PCL::|METHOD-CALL SLOT0|
+   PCL::GF-FAST-METHOD-FUNCTION-P PCL::|INITIALIZE-INFO SLOT9|
+   PCL::|INITIALIZE-INFO SLOT8| PCL::|INITIALIZE-INFO SLOT7|
+   PCL::|INITIALIZE-INFO SLOT6| PCL::|INITIALIZE-INFO SLOT5|
+   PCL::|INITIALIZE-INFO SLOT4| PCL::|INITIALIZE-INFO SLOT3|
+   PCL::|INITIALIZE-INFO SLOT2| PCL::|INITIALIZE-INFO SLOT1|
+   PCL::|INITIALIZE-INFO SLOT0| PCL::|CACHE SLOT11| PCL::|CACHE SLOT10|
+   PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::MAKE-CLASS-PREDICATE-NAME
+   PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS PCL::CLASS-CONSTRUCTORS
+   PCL::|ARG-INFO SLOT9| PCL::|ARG-INFO SLOT8| PCL::|ARG-INFO SLOT7|
+   PCL::|ARG-INFO SLOT6| PCL::|ARG-INFO SLOT5| PCL::|ARG-INFO SLOT4|
+   PCL::|COMPILER::FN SLOT8| PCL::|ARG-INFO SLOT3|
+   PCL::SPECIALIZER-METHOD-TABLE PCL::|COMPILER::FN SLOT7|
+   PCL::|ARG-INFO SLOT2| PCL::|COMPILER::FN SLOT6|
+   PCL::|ARG-INFO SLOT1| PCL::|COMPILER::FN SLOT5|
+   PCL::|ARG-INFO SLOT0| PCL::|COMPILER::FN SLOT4|
+   PCL::|COMPILER::FN SLOT3| PCL::|COMPILER::FN SLOT2|
+   PCL::|COMPILER::FN SLOT1| PCL::|COMPILER::FN SLOT0|
+   PCL::|TYPE-PREDICATE COMMON-LISP STRUCTURE-CLASS|
+   PCL::|TYPE-PREDICATE COMMON-LISP BUILT-IN-CLASS|
+   PCL::|TYPE-PREDICATE PCL FORWARD-REFERENCED-CLASS|
+   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-CLASS|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-CLASS|
+   PCL::|TYPE-PREDICATE PCL STD-CLASS|
+   PCL::|TYPE-PREDICATE PCL SLOT-CLASS|
+   PCL::|TYPE-PREDICATE PCL PCL-CLASS|
+   PCL::|TYPE-PREDICATE COMMON-LISP CLASS|
+   PCL::|TYPE-PREDICATE PCL SPECIALIZER-WITH-OBJECT|
+   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-OBJECT|
+   PCL::|TYPE-PREDICATE PCL METAOBJECT|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-OBJECT|
+   PCL::|TYPE-PREDICATE PCL SHORT-METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE PCL LONG-METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE COMMON-LISP METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-GENERIC-FUNCTION|
+   PCL::|TYPE-PREDICATE COMMON-LISP GENERIC-FUNCTION|
+   PCL::|TYPE-PREDICATE PCL STRUCTURE-EFFECTIVE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STRUCTURE-DIRECT-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-EFFECTIVE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-DIRECT-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL EFFECTIVE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL DIRECT-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STRUCTURE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL SLOT-DEFINITION| PCL::GET-DISPATCH-FUNCTION
+   PCL::|FAST-METHOD-CALL SLOT3| PCL::|FAST-METHOD-CALL SLOT2|
+   PCL::INITIALIZE-INTERNAL-SLOT-FUNCTIONS
+   PCL::|FAST-METHOD-CALL SLOT1| PCL::GF-LAMBDA-LIST
+   PCL::|FAST-METHOD-CALL SLOT0| PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::|TYPE-PREDICATE PCL TRACED-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-BOUNDP-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-WRITER-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-READER-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-ACCESSOR-METHOD|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-METHOD|
+   PCL::|TYPE-PREDICATE COMMON-LISP METHOD| PCL::|SYSTEM:S-DATA SLOT17|
+   PCL::|SYSTEM:S-DATA SLOT16| PCL::|SYSTEM:S-DATA SLOT15|
+   PCL::|SYSTEM:S-DATA SLOT14| PCL::|SYSTEM:S-DATA SLOT13|
+   PCL::|SYSTEM:S-DATA SLOT12| PCL::|SYSTEM:S-DATA SLOT11|
+   PCL::|SYSTEM:S-DATA SLOT10| PCL::|ONE-INDEX-DFUN-INFO SLOT2|
+   PCL::CLASS-PREDICATE-NAME PCL::|TWO-CLASS SLOT4| PCL::|CACHE SLOT9|
+   PCL::GENERIC-FUNCTION-PRETTY-ARGLIST PCL::|CACHE SLOT8|
+   PCL::|CACHE SLOT7| PCL::|CACHE SLOT6| PCL::|CACHE SLOT5|
+   PCL::|CACHE SLOT4| PCL::|CACHE SLOT3| PCL::ACCESSOR-METHOD-CLASS
+   PCL::|CACHE SLOT2| PCL::|CACHE SLOT1| PCL::|CACHE SLOT0|
+   PCL::|ONE-CLASS SLOT3| PCL::METHOD-PRETTY-ARGLIST
+   PCL::|INITIALIZE-INFO SLOT13| PCL::KEYWORD-SPEC-NAME
+   PCL::|INITIALIZE-INFO SLOT12|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT3|
+   PCL::|INITIALIZE-INFO SLOT11|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT2|
+   PCL::|INITIALIZE-INFO SLOT10|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT1|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT0| PCL::|MODULE SLOT4|
+   PCL::|MODULE SLOT3| PCL::|MODULE SLOT2| PCL::SPECIALIZER-CLASS
+   PCL::|MODULE SLOT1| PCL::ACCESSOR-METHOD-SLOT-NAME
+   PCL::|MODULE SLOT0| PCL::METHOD-PROTOTYPE-FOR-GF
+   PCL::SLOT-VECTOR-SYMBOL PCL::SLOT-READER-SYMBOL
+   PCL::SPECIALIZER-FROM-TYPE PCL::INSURE-CACHING-DFUN
+   PCL::|ACCESSOR-DFUN-INFO SLOT1| PCL::|FAST-INSTANCE-BOUNDP SLOT0|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
     (OR
-     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-     (SYSTEM:INTERPRETED-FUNCTION)))
-   PCL::GET-NEW-FUNCTION-GENERATOR PCL::TRACE-METHOD-INTERNAL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL:SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) NIL)
-   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
-   PCL::COPY-TWO-CLASS)) 
+     (OR
+      (OR
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::SORT-METHODS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T) (T))
     (VALUES
-     &OPTIONAL (SYSTEM:PROPER-CONS (T) (T))
+     (SYSTEM:PROPER-CONS (T) (T))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
    PCL::REAL-MAKE-METHOD-LAMBDA)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
-    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
-   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
+(PROCLAIM '(FTYPE (FUNCTION NIL (VALUES)) PCL::COUNT-ALL-DFUNS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
+   (FUNCTION ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (INTEGER 0 12) (MEMBER NIL)))
-   PCL::WRAPPER-FIELD)) 
+   (FUNCTION ((STRUCTURE PCL::FAST-METHOD-CALL)) (T))
+   PCL::FAST-METHOD-CALL-ARG-INFO
+   PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
+   PCL::FAST-METHOD-CALL-PV-CELL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CACHE))
-    (OR
-     (OR
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-     (SYSTEM:INTERPRETED-FUNCTION)))
-   PCL::CACHE-LIMIT-FN)) 
+   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
+   PCL::CONSTANT-VALUE-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::COMPILE-LAMBDA-UNCOMPILED PCL::MAKE-EQL-PREDICATE
-   PCL::CLASS-PREDICATE PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
-   PCL::EVAL-FORM PCL::COMPILE-LAMBDA-DEFERRED PCL::MAKE-TYPE-PREDICATE
-   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
-   PCL::MAKE-TRAMPOLINE PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION
-   PCL::MAKE-CLASS-EQ-PREDICATE PCL::MAKE-CONSTANT-FUNCTION)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (VALUES &REST T))
+   ITERATE::ITERATE-TRANSFORM-BODY
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL)))
-    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::PARSE-SPECIALIZERS)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
-   PCL::COPY-NO-METHODS)) 
+    ((T) (T) (T) (T) (T) (T))
+    (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (T)) PCL::ONE-INDEX-CACHE
-   PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-ACCESSOR-TYPE)) 
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T))
+    (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (NULL) (T)) (T))
-   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::LOAD-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
+    ((T) (T) (T) (T))
     (VALUES
-     &OPTIONAL (SYSTEM:PROPER-CONS (T) (T))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   MAKE-LOAD-FORM-SAVING-SLOTS PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
+     (OR
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-   PCL::MAKE-DISPATCH-LAMBDA)) 
+   (FUNCTION ((T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::USE-DISPATCH-DFUN-P PCL::USE-CONSTANT-VALUE-DFUN-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) (T) (T))
     (OR
-     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-     (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))
-     (MEMBER NIL)))
-   PCL::METHODS-CONVERTER)) 
+     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+     (MEMBER T)))
+   PCL::OPTIMIZE-SLOT-BOUNDP PCL::OPTIMIZE-SLOT-VALUE
+   PCL::OPTIMIZE-SET-SLOT-VALUE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) &REST T)
-    (VALUES
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION))
-     (T)))
-   PCL::GET-FUNCTION1)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
-    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
-   PCL::MAKE-INSTANCE-FUNCTION-COMPLEX)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
-   PCL::CONSTANT-VALUE-CACHE)) 
+    ((T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-REPEAT-EVAL PCL::COMPUTE-STD-CPL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T)) (OR (MEMBER "a string or NULL") (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
-   PCL::|__si::MAKE-CACHING|)) 
+    ((T) (T))
+    (OR
+     (MEMBER
+      PCL:STANDARD-INSTANCE PCL::STRUCTURE-INSTANCE
+      PCL::BUILT-IN-INSTANCE PCL::SLOT-INSTANCE CLASS)
+     (MEMBER T)))
+   PCL::RAISE-METATYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
-   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
-   PCL::CACHE-SIZE)) 
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (CLASS))| PCL::EXPAND-DEFCLASS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES
-     (T)
-     (OR
-      (SYSTEM::NON-SIMPLE-ARRAY T *) (SIMPLE-ARRAY T *) (MEMBER NIL))))
-   PCL::MAKE-SHARED-INITIALIZE-FORM-LIST)) 
+    ((STRUCTURE PCL::PV-TABLE))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::PV-TABLE-PV-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T))
-    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
-   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
+   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (T)) PCL::TWO-CLASS-CACHE
+   PCL::TWO-CLASS-INDEX PCL::TWO-CLASS-WRAPPER1 PCL::TWO-CLASS-WRAPPER0
+   PCL::TWO-CLASS-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
+    ((T) (T))
+    (OR
      (OR
-      (MEMBER NIL)
       (OR
-       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)))))
-   PCL::MAKE-FINAL-ACCESSOR-DFUN)) 
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::FIND-SUPERCLASS-CHAIN
+   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::USE-DISPATCH-DFUN-P PCL::USE-CONSTANT-VALUE-DFUN-P)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::COPY-ONE-CLASS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
+    ((T) (T) (T))
     (OR
-     (SYSTEM:COMPLEX* (LONG-FLOAT * *) (LONG-FLOAT * *))
-     (SYSTEM:COMPLEX* (RATIO * *) (RATIO * *))
-     (SYSTEM:COMPLEX* (RATIO * *) (INTEGER * *)) (LONG-FLOAT * *)
-     (RATIO * *) (INTEGER * *) (SHORT-FLOAT * *)
-     (SYSTEM:COMPLEX* (INTEGER * *) (RATIO * *))
-     (SYSTEM:COMPLEX* (INTEGER * *) (INTEGER * *))
-     (SYSTEM:COMPLEX* (SHORT-FLOAT * *) (SHORT-FLOAT * *))
-     (MEMBER NIL)))
-   PCL::COUNT-DFUN)) 
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::GET-NEW-FUNCTION-GENERATOR PCL::TRACE-METHOD-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (NULL)) PCL::PRINT-CACHE
-   PCL::NOTE-PV-TABLE-REFERENCE PCL::FIX-SLOT-ACCESSORS
-   PCL::CHECK-METHOD-ARG-INFO
-   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
-   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
-   PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))|
-   PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
-   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))|
-   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
-   PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
-   PCL::INITIALIZE-INTERNAL-SLOT-GFS*)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (NULL))
-   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
-   PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
-   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (NULL))
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
+   PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1
+   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
+   (FUNCTION ((T) (T) &REST T) (VALUES (T) (T)))
+   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
-   PCL::GET-MAKE-INSTANCE-FUNCTION)) 
+    ((T) (T) &REST T)
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
+   PCL::MAKE-N-N-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   ITERATE::FUNCTION-LAMBDA-P)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
-   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
-   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
\ No newline at end of file
+    ((T) (T) (T) (T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
\ No newline at end of file
--- gcl27-2.7.0.orig/unixport/init_raw.lsp.in
+++ gcl27-2.7.0/unixport/init_raw.lsp.in
@@ -2,17 +2,18 @@
 (defun make-package (name &key nicknames use)
   (si::make-package-int name nicknames use))
 
-(make-package :s :use '(:cl))
-(make-package :compiler :use '(:cl :si :s))
+(make-package :cstruct :use '(:cl))
+(make-package :compiler :use '(:cl :si :cstruct))
 (make-package :sloop :use '(:cl))
 (make-package :ansi-loop :use'(:cl))
 (make-package :defpackage :use '(:cl))
 (make-package :tk :use '(:cl :sloop))
 (make-package :fpe :use '(:cl))
 (make-package :cltl1-compat)
+(make-package "libm")
 
 (in-package :system)
-(use-package '(:fpe :s :gmp))
+(use-package '(:fpe :cstruct :gmp))
 
 (export 'si::(object double cnum system cmp-inline cmp-eval type-propagator c1no-side-effects defcfun clines defentry) :si);FIXME
 
@@ -72,8 +73,6 @@
 (gbc t)
 (reset-gbc-count)
 
-(defun top-level nil (gcl-top-level))
-
 (set-up-top-level)
 
 (setq *gcl-extra-version* @LI-EXTVERS@
--- gcl27-2.7.0.orig/xgcl-2/gcl_tohtml.lsp
+++ gcl27-2.7.0/xgcl-2/gcl_tohtml.lsp
@@ -61,7 +61,7 @@
 ; Make a contents list for a file of LaTex slides
 ; n is first page number: required if first page is not 1.
 ; html is prefix string to make html contents
-(in-package 'xlib)
+(in-package "XLIB")
 
 (defvar *line*)
 (defvar *ptr*)
