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-33) unstable; urgency=medium
 .
   * Version_2_7_0pre36
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: 2025-02-12

--- gcl27-2.7.0.orig/clcs/gcl_clcs_condition_definitions.lisp
+++ gcl27-2.7.0/clcs/gcl_clcs_condition_definitions.lisp
@@ -116,7 +116,7 @@
   (:report (lambda (condition stream &aux (x (pcl::slot-value-normal condition 'function-name)));FIXME
 	     (when x
 	       (if (stringp x);FIXME compiler context
-		   (format stream x)
+		   (format stream "~a" x)
 		   (format stream "Condition in ~S [or a callee]: " x)))
 	     (call-next-method))))
 
--- gcl27-2.7.0.orig/clcs/makefile
+++ gcl27-2.7.0/clcs/makefile
@@ -9,7 +9,7 @@ APPEND=../xbin/append
 all: $(addsuffix .c,$(FILES)) $(addsuffix .h,$(FILES)) $(addsuffix .data,$(FILES)) $(addsuffix .o,$(FILES))
 
 $(addsuffix .c,$(FILES)) $(addsuffix .h,$(FILES)) $(addsuffix .data,$(FILES)) $(addsuffix .o,$(FILES)):	$(addsuffix .lisp,$(FILES)) ./saved_clcs_gcl
-	echo "(progn (compiler::cdebug) (mapc (quote compile-file) (mapcar (quote string-downcase) (quote ($(addsuffix .lisp,$(FILES)))))) (compiler::dump-inl-hash \"../cmpnew/gcl_cmpnopt.lsp\"))" | ./saved_clcs_gcl
+	echo "(progn (compiler::cdebug) (mapc (quote compile-file) (mapcar (quote string-downcase) (quote ($(addsuffix .lisp,$(FILES)))))) (compiler::dump-inl-hash \"../cmpnew/gcl_cmpnopt_ansi.lsp\"))" | ./saved_clcs_gcl
 
 
 gprof_objs: $(addprefix ../gprof/,$(addsuffix .o,$(FILES)))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpeval.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpeval.lsp
@@ -2211,6 +2211,9 @@
     (list* 'str-ref info nargs)))
 (setf (get 'str-ref 'c1) 'c1str-ref)
 
+(defun sinline-type (tp);FIXME STREF STSET handled as aref
+  (if (type= tp #tcharacter) 'inline-character (inline-type tp)))
+
 (defun c2str-ref (loc nm off)
   (let* ((nm (car (atomic-tp (info-type (cadr nm)))))
 	 (sd (get nm 'si::s-data))
@@ -2218,7 +2221,7 @@
 	 (off (car (atomic-tp (info-type (cadr off))))))
     (unless (and off sd (not *compiler-push-events*)) (baboon))
     (unwind-exit
-     (list (inline-type (nth (aref (si::s-data-raw sd) off) +cmp-array-types+))
+     (list (sinline-type (nth (aref (si::s-data-raw sd) off) +cmp-array-types+));FIXME STREF STSET handled as aref
 	   (flags) 'my-call (list loc nil off sd)))
     (close-inline-blocks)))
 (setf (get 'str-ref 'c2) 'c2str-ref)
@@ -2246,8 +2249,11 @@
            (si:fixnump (caddr args))
            (not (endp (cdddr args)))
            (endp (cddddr args)))
-      (let ((x (c1arg (car args) info))
-            (y (c1arg (cadddr args) info)))
+      (let* ((x (c1arg (car args) info))
+	     (sd (get (cadadr args) 'si::s-data))
+	     (raw (si::s-data-raw sd))
+	     (type (nth (aref raw (caddr args)) +cmp-array-types+))
+             (y (c1arg (if (type= #tcharacter type) `(char-code ,(cadddr args)) (cadddr args)) info)));FIXME STREF STSET handled as aref
         (setf (info-type info) (info-type (cadr y)))
         (list 'structure-set info x
               (cadadr args) ;;; remove QUOTE.
@@ -2289,6 +2295,7 @@
   (declare (ignore name-vv))
   (let* ((raw (si::s-data-raw sd))
 	 (type (nth (aref raw ind) +cmp-array-types+))
+	 (type (if (type= #tcharacter type) (car (assoc #tchar +c-type-string-alist+ :test 'type=)) type));FIXME STREF STSET handled as aref)
 	 (spos (si::s-data-slot-position sd))
 	 (tftype type)
 	 ix iy)
@@ -2301,8 +2308,8 @@
     (setq ix (car locs))
     (setq iy (cadr locs))
     (if *safe-compile* (wfs-error))
-    (wt-nl "STSET(" (aet-c-type type )"," ix "," (aref spos ind) ", " iy ");")
-    (unwind-exit (list (inline-type tftype) (flags) 'wt-loc (list iy)))
+    (wt-nl "STSET(" (aet-c-type type) "," ix "," (aref spos ind) ", " iy ");");FIXME STREF STSET handled as aref
+    (unwind-exit (list (sinline-type tftype) (flags) 'wt-loc (list iy)))
     (close-inline-blocks)))
 
 (defun sv-wrap (x) `(symbol-value ',x))
@@ -2353,7 +2360,12 @@
     (let ((l (c1constant-value-object val (or always (when *compiler-compile* (not *keep-gaz*))))))
       (when l 
 	`(location 
-	  ,(make-info :type (or (ltvp val) (object-type (if (functionp val) (afe (cons 'df nil) (mf (fle val))) val))))
+	  ,(make-info :type (or (ltvp val)
+				(object-type
+				 (typecase val
+				   (function  (afe (cons 'df nil) (mf (fle val))))
+				   (list (copy-tree val))
+				   (t val)))))
 	  ,l))))))
 
 (defvar *compiler-temps*
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpflet.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpflet.lsp
@@ -85,6 +85,18 @@
 ;;; is a list ( macro-name expansion-function).
 
 (defvar *restore-vars-env* nil)
+(defun repl-lst (l m &optional o)
+  (typecase l
+    (cons (cond ((consp m) (setf (car l) (repl-lst (car l) (car m) o) (cdr l) (repl-lst (cdr l) (cdr m) o)) l)(m)))
+    (t (if (eql l m) l (if o (new-bind) m)))))
+
+(defun repl-tp (tp m &optional o)
+  (unless (equal tp m)
+    (let* ((atp (atomic-tp tp))(am (atomic-tp m)))
+      (when (and atp am);FIXME redundant?
+	(repl-lst (car atp) (car am) o))))
+  tp)
+
 (defmacro with-restore-vars (&rest body &aux (rv (sgen "WRV-"))(wns (sgen "WRVW-")))
   `(let (,rv (,wns *warning-note-stack*))
      (declare (ignorable ,rv))
@@ -92,11 +104,15 @@
 	      (keep-warnings nil (setq ,wns *warning-note-stack*))
 	      (pop-restore-vars nil
 	       (setq *warning-note-stack* ,wns)
-	       (mapc (lambda (l &aux (v (pop l))(tp (pop l))(st (car l)))
-		       (keyed-cmpnote (list (var-name v) 'type-propagation 'type)
-				      "Restoring var type on ~s from ~s to ~s"
-				      (var-name v) (cmp-unnorm-tp (var-type v)) (cmp-unnorm-tp tp))
-		       (setf (var-type v) tp (var-store v) st))
+	       (mapc (lambda (l &aux (v (pop l))(tp (pop l))(st (pop l)))
+		       (cond ((var-p v)
+			      (keyed-cmpnote (list (var-name v) 'type-propagation 'type)
+					     "Restoring var type on ~s from ~s to ~s"
+					     (var-name v) (cmp-unnorm-tp (var-type v)) (cmp-unnorm-tp tp))
+			      (setf (var-type v) tp (var-store v) st))
+			     (t
+			      (keyed-cmpnote (list 'type-mod-unwind)	"Unwinding type ~s ~s" v tp)
+			      (repl-tp v tp))))
 		     (ldiff-nf *restore-vars* ,rv))))
        (declare (ignorable #'keep-vars))
        (prog1
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpif.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpif.lsp
@@ -306,7 +306,12 @@
       (with-restore-vars ;FIXME eliminate if any variable restricts to nil
 	(dolist (l r) (restrict-type (car l) (cadr l) (let ((l (caddr l))) (if tf (car l) (cdr l)))))
 	(let (trv (b (c1expr* (if tf (cadr args) (caddr args)) info)))
-	  (dolist (l *restore-vars*) (push (list (car l) (var-type (car l)) (var-store (car l))) trv));)
+	  (dolist (l *restore-vars*)
+	    (push (if (var-p (car l))
+		      (list (car l) (var-type (car l)) (var-store (car l)))
+		      (progn (keyed-cmpnote (list 'type-mod-unwind) "Winding type ~s at end of branch" (car l))
+			     (list (car l) (mcpt (car l)))))
+		  trv))
 	  (keep-warnings)
 	  (list b trv)))))
 
@@ -402,13 +407,17 @@
 			     (do-setq-tp (car rv) nil (type-and (car (caddr rv)) (var-type (car rv)))))))
 
 		     (do (rv) ((not (setq rv (pop trv))))
-			 (unless (subsetp (caddr rv) (var-store (car rv)))
-			   (keyed-cmpnote
-			    (list (var-name (car rv)) 'var-store 'binding '+opaque+)
-			    "~s store set to +opaque+ from ~s/~s across if branches"
-			    (var-name (car rv)) (caddr rv) (var-store (car rv)))
-			   (push-vbinds (car rv) (caddr rv)))
-			 (do-setq-tp (car rv) (list args nil) (type-or1 (var-type (car rv)) (cadr rv))))
+		       (cond ((var-p (car rv))
+			      (unless (subsetp (caddr rv) (var-store (car rv)))
+				(keyed-cmpnote
+				 (list (var-name (car rv)) 'var-store 'binding '+opaque+)
+				 "~s store set to +opaque+ from ~s/~s across if branches"
+				 (var-name (car rv)) (caddr rv) (var-store (car rv)))
+				(push-vbinds (car rv) (caddr rv)))
+			      (do-setq-tp (car rv) (list args nil) (type-or1 (var-type (car rv)) (cadr rv))))
+			     (t
+			      (keyed-cmpnote (list 'type-mod-unwind) "Unwinding type ~s ~s" (car rv) (cadr rv))
+			      (repl-tp (car rv) (cadr rv) t))))
 
 		     (list 'if info fmla tb fb))
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpopt.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpopt.lsp
@@ -1141,6 +1141,7 @@
 	     (:dcomplex   "make_dcomplex"        dcomplex        cnum)
 	     (:string     "make_simple_string"   string)
 	     (:object     ""                     t)
+	     (:char*      nil                    nil             (array character)   "->st.st_self")
 	     (:float*     nil                    nil             (array short-float) "->sfa.sfa_self")
 	     (:double*    nil                    nil             (array long-float)  "->lfa.lfa_self")
 	     (:long*      nil                    nil             (array fixnum)      "->fixa.fixa_self")
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptop.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptop.lsp
@@ -1086,15 +1086,14 @@
     (unless (or (equal osig sig) (eq fname 'cmp-anon));FIXME
       (cmpstyle-warn "signature change on function ~s,~%   ~s -> ~s~%"
 		     fname (si::readable-sig osig) (si::readable-sig sig))
-      (setq *new-sigs-in-file* 
-	    (some
-	     (lambda (x) 
-	       (unless (eq x fname)
-		 (multiple-value-bind 
-		  (s f) (gethash x *sigs*) 
-		  (declare (ignore s))
-		  (when f (list x fname osig sig)))))
-	     (si::callers fname))))
+      (setq *new-sigs-in-file*
+	    (block nil
+	      (maphash (lambda (x y)
+			 (unless (eq x fname)
+			   (when (member fname (second y) :key 'car)
+			     (return (list x fname osig sig)))))
+		       *sigs*)
+	      nil)))
     
     (push (let* ((at (car sig))
 		 (al (mapcar (lambda (x) (link-rt x nil)) at))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptype.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptype.lsp
@@ -752,6 +752,9 @@
     (c1side-effects nil)
     (cond
       ((and c1 atp2 (not (eq c1 a2)) (if (typep c1 'proper-cons) (typep a2 'proper-list) (typep a2 '(not proper-list))))
+       (when *restore-vars-env*
+	 (keyed-cmpnote (list 'type-mod-unwind) "Winding type ~s for rplacd" tp1)
+	 (pushnew (list tp1 (mcpt tp1)) *restore-vars* :key 'car))
        (setf (cdr c1) a2 itp tp1))
       ((and (typep c1 'proper-cons) (type<= tp2 #tproper-list))
        (bump-cons-tp-if (lambda (x &aux (c (car (atomic-tp x)))) (when (consp c) (tailp c1 c))) #tproper-cons))
@@ -768,12 +771,16 @@
 (defun c1rplaca (args)
   (let* ((info (make-info :flags (iflags side-effects)))
 	 (nargs (c1args args info))
-	 (atp (car (atomic-tp (info-type (cadar nargs)))))
+	 (tp1 (info-type (cadar nargs)))
+	 (atp (car (atomic-tp tp1)))
 ;	 (atp1 (car (atomic-tp (narg-list-type (cdr nargs))))))
 	 (atp1 (car (atomic-tp (info-type (cadadr nargs))))))
     (c1side-effects nil)
     (when (consp atp) 
       (when (eq atp atp1) (setq atp1 (copy-list atp1)))
+      (when *restore-vars-env*
+	(keyed-cmpnote (list 'type-mod-unwind)	"Winding type ~s for rplaca" tp1)
+	(let ((tp (info-type (cadar nargs)))) (pushnew (list tp (mcpt tp)) *restore-vars* :key 'car)))
       (setf (car atp) (or atp1 (new-bind))))
     (when (eq (caar nargs) 'var)
       (bump-pconsa (caaddr (car nargs)) (info-type (cadadr nargs))))
--- gcl27-2.7.0.orig/gcl-tk/tkMain.c
+++ gcl27-2.7.0/gcl-tk/tkMain.c
@@ -37,7 +37,9 @@
 #include <stdlib.h>
 #include <tcl.h>
 #include <tk.h>
-
+#if TCL_MAJOR_VERSION >= 9
+#include <wordexp.h>
+#endif
 
 
 #if (TK_MINOR_VERSION==0 && TK_MAJOR_VERSION==4)
@@ -68,12 +70,12 @@ struct connection_state *dsfd;
  * file out of the Tk source directory to make their own modified versions).
  */
 
-/* extern void		exit _ANSI_ARGS_((int status)); */
+/* extern void		exit _ANSI_ARGS_((int status));
 extern int		isatty _ANSI_ARGS_((int fd));
-/*
 extern int		read _ANSI_ARGS_((int fd, char *buf, size_t size));
-*/
 extern char *		strrchr _ANSI_ARGS_((CONST char *string, int c));
+*/
+extern int Tcl_AppInit(Tcl_Interp *interp);
 
 /*
  * Global variables used by the main program:
@@ -332,11 +334,17 @@ TkX_Wish (argc, argv)
 	 */
 
 	if (tcl_RcFileName != NULL) {
-	    Tcl_DString buffer;
 	    char *fullName;
 	    FILE *f;
+#if TCL_MAJOR_VERSION >= 9
+	    wordexp_t exp_result;
+	    wordexp(tcl_RcFileName, &exp_result, WRDE_NOCMD);
+	    fullName = exp_result.we_wordv[0];
+#else
+	    Tcl_DString buffer;
     
 	    fullName = Tcl_TildeSubst(interp, tcl_RcFileName, &buffer);
+#endif
 	    if (fullName == NULL) {
 		fprintf(stderr, "%s\n", INTERP_RESULT(interp));
 	    } else {
@@ -349,12 +357,16 @@ TkX_Wish (argc, argv)
 		    fclose(f);
 		}
 	    }
+#if TCL_MAJOR_VERSION >= 9
+	    wordfree(&exp_result);
+#else
 	    Tcl_DStringFree(&buffer);
+#endif
 	}
 
 	dfprintf(stderr, "guis : Creating file handler for %d\n", dsfd->fd);
 #ifndef __MINGW32__	
-	Tk_CreateFileHandler(dsfd->fd, TK_READABLE, StdinProc, (ClientData) 0);
+	Tcl_CreateFileHandler(dsfd->fd, TCL_READABLE, StdinProc, (ClientData) 0);
 #endif        
     }
     fflush(stdout);
@@ -467,7 +479,7 @@ StdinProc(clientData, mask)
    */
   dfprintf(stderr, "\nguis : Disabling file handler for %d\n", dsfd->fd);
 
-/*  Tk_CreateFileHandler(dsfd->fd, 0, StdinProc, (ClientData) 0); */
+/*  Tcl_CreateFileHandler(dsfd->fd, 0, StdinProc, (ClientData) 0); */
 
   do
     { 
@@ -479,7 +491,7 @@ StdinProc(clientData, mask)
 	  /*dfprintf(stderr, "Yoo !!! Empty command\n"); */
 	  if (debug)perror("zero message");
 #ifndef __MINGW32__          
-	  Tk_CreateFileHandler(dsfd->fd, TK_READABLE, StdinProc, (ClientData) 0);
+	  Tcl_CreateFileHandler(dsfd->fd, TCL_READABLE, StdinProc, (ClientData) 0);
 #endif          
 	  return;
 	}
@@ -581,7 +593,7 @@ StdinProc(clientData, mask)
     } while (fNotDone > 0);
 
 
-  /* Tk_CreateFileHandler(dsfd->fd, TK_READABLE, StdinProc, (ClientData) 0); */
+  /* Tcl_CreateFileHandler(dsfd->fd, TCL_READABLE, StdinProc, (ClientData) 0); */
   if ((void *)msg != (void *) buf)
     free ((void *) msg);
 }
--- gcl27-2.7.0.orig/git.tag
+++ gcl27-2.7.0/git.tag
@@ -1,2 +1,2 @@
-"Version_2_7_0pre35"
+"Version_2_7_0pre36"
 
--- gcl27-2.7.0.orig/h/compprotos.h
+++ gcl27-2.7.0/h/compprotos.h
@@ -96,6 +96,7 @@ object Icall_gen_error_handler(object,ob
 object Icall_gen_error_handler_noreturn(object,object,object,object,ufixnum,...) __attribute__((noreturn));
 object file_stream(object);
 fixnum fixnum_expt(fixnum, fixnum);
+char *gcl_gets(char *,int);
 int gcl_puts(const char *);
 int setjmp();
 int _setjmp();
--- gcl27-2.7.0.orig/h/lu.h
+++ gcl27-2.7.0/h/lu.h
@@ -413,6 +413,16 @@ struct structure {  /*  structure header
 
 };
 
+struct strstd {  /*  structure header  */
+
+  FIRSTWORD;
+
+  structure  strstd_sdef;  /*  structure definition (a structure)  */
+  object    *strstd_sself; /*  structure self  */
+  SPAD;
+
+};
+
 struct stream {
 
   FIRSTWORD;
@@ -552,6 +562,7 @@ union lispunion {
  struct matrix             mt; /*  matrix  */
  struct adjarray         aadj; /*  adjustable array  */
  struct structure         str; /*  structure  */
+ struct strstd         strstd; /*  structure  */
  struct stream             sm; /*  stream  */
  struct random            rnd; /*  random-states  */
  struct readtable          rt; /*  read table  */
--- gcl27-2.7.0.orig/h/notcomp.h
+++ gcl27-2.7.0/h/notcomp.h
@@ -102,6 +102,7 @@ EXTER object user_package;
 #define make_macro_function(a_,b_) make_macro_internal(a_,b_)
 #define make_si_function(a_,b_) make_si_function_internal(a_,b_)
 #define make_special_form(a_,b_) make_special_form_internal(a_,b_)
+#define make_si_special_form(a_,b_) make_si_special_form_internal(a_,FFN(b_))
 #define make_macro_function(a_,b_) make_macro_internal(a_,b_)
 #define make_si_sfun(a_,b_,c_) make_si_sfun_internal(a_,b_,c_)
 #define STATD
--- gcl27-2.7.0.orig/h/protoize.h
+++ gcl27-2.7.0/h/protoize.h
@@ -87,7 +87,8 @@ struct key {short n,allow_other_keys;
 /* cfun.c:283:OF */ extern object make_macro_internal (char *s, void(*f)()); /* (s, f) char *s; int (*f)(); */
 /* cfun.c:299:OF */ extern object make_si_sfun_internal (char *s, object (*f)(), int argd); /* (s, f, argd) char *s; int (*f)(); int argd; */
 /* cfun.c:322:OF */ extern object make_si_function_internal (char *s, void (*f) ()); /* (s, f) char *s; int (*f)(); */
-/* cfun.c:341:OF */ extern object make_special_form_internal (char *s, void * f); /* (s, f) char *s; int (*f)(); */
+/* cfun.c:341:OF */ extern object make_special_form_internal (char *s, void *f); /* (s, f) char *s; int (*f)(); */
+/* cfun.c:341:OF */ extern object make_si_special_form_internal (char *s, void *f); /* (s, f) char *s; int (*f)(); */
 /* cfun.c:371:OF */ extern void turbo_closure (object fun); /* (fun) object fun; */
 /* cfun.c:403:OF */ extern void gcl_init_cfun (void); /* () */
 /* cmac.c:191:OF */ extern void gcl_init_cmac (void); /* () */
--- gcl27-2.7.0.orig/lsp/gcl_arraylib.lsp
+++ gcl27-2.7.0/lsp/gcl_arraylib.lsp
@@ -25,24 +25,21 @@
 
 (in-package :system)
 
-(eval-when 
- (compile eval)
-
- (defun proto-array (tp) (make-vector tp 1 t nil nil 0 nil nil))
-
- (defun af (x) (cdr (assoc x '((character . *char) (bit . *char) (non-negative-char . *char);fixme
-			       (unsigned-char . *uchar) (signed-char . *char)
-			       #+64bit (non-negative-int . *int) #+64bit (unsigned-int . *uint) #+64bit (signed-int . *int)
-			       (non-negative-short . *short) (unsigned-short . *ushort)
-			       (signed-short . *short) (short-float . *float) (long-float . *double)
-			       (t . *object) (non-negative-fixnum . *fixnum) (fixnum . *fixnum)))))
- 
- (defvar *array-type-info* (mapcar (lambda (x &aux (y (proto-array x))) 
-				     (list x (c-array-elttype y) (c-array-eltsize y) (c-array-eltmode y) (af x)))
-				   +array-types+))
-
- (defun maybe-cons (car cdr)
-   (if (cdr cdr) (cons car cdr) (car cdr))))
+(defconstant +array-type-info+
+  (mapcar (lambda (x &aux (y (make-vector x 1 t nil nil 0 nil nil)))
+	    (list x (c-array-elttype y) (c-array-eltsize y) (c-array-eltmode y)
+		  (ecase x
+		    (signed-char '*char)
+		    ((character unsigned-char non-negative-char bit) '*uchar)
+		    (signed-short '*short)
+		    ((unsigned-short non-negative-short) '*ushort)
+		    (signed-int '*int)
+		    ((unsigned-int non-negative-int) '*uint)
+		    (short-float '*float)
+		    (long-float '*double)
+		    (t '*object)
+		    ((non-negative-fixnum fixnum) '*fixnum))))
+	  +array-types+))
 
 #.`(defun set-array (r i s j &optional sw);assumes arrays of same type and indices in bounds
      (declare (optimize (safety 1))(seqind i j))
@@ -66,7 +63,7 @@
 		  (lreduce (lambda (y x &aux (sz (caddr x))(fn (fifth x))(z (assoc sz y))(tp (cmp-norm-tp `(array ,(car x)))))
 			     (cond (z (setf (cadr z) (tp-or (cadr z) tp) (caddr z) fn) y)
 				   ((cons (list sz tp fn) y))))
-			   si::*array-type-info* :initial-value nil)))))
+			   +array-type-info+ :initial-value nil)))))
 (declaim (inline set-array))
 
 (defun set-array-n (r i s j n);assumes arrays of same type and indices in bounds
@@ -86,7 +83,7 @@
      (check-type x array)
      (case
 	 (c-array-elttype x)
-       ,@(mapcar (lambda (x &aux (tp (pop x))) `(,(car x) ',tp)) *array-type-info*)))
+       ,@(mapcar (lambda (x &aux (tp (pop x))) `(,(car x) ',tp)) +array-type-info+)))
 
 #.`(defun row-major-aref-int (a i)
      (ecase
@@ -97,7 +94,7 @@
 			(character `(code-char (*uchar (c-array-self a) i nil nil)))
 			(bit `(0-byte-array-self a i))
 			(otherwise `(,(caddr y) (c-array-self a) i nil nil)))))
-		 *array-type-info*)))
+		 +array-type-info+)))
 (declaim (inline row-major-aref-int))
 
 (defun row-major-aref (a i)
@@ -121,7 +118,7 @@
 			(character `(code-char (*uchar (c-array-self a) i t (char-code v))))
 			(bit `(set-0-byte-array-self v a i))
 			(otherwise `(,(caddr y) (c-array-self a) i t v)))))
-		 *array-type-info*)))
+		 +array-type-info+)))
 (setf (get 'row-major-aset 'compiler::consider-inline) t)
 
 
@@ -177,7 +174,7 @@
       (let ((x a))(check-type x vector))
       (let ((x a))(check-type x matrix)))
   (row-major-aset v a (apply 'array-row-major-index a q)))
-(declaim (inline si::aset))
+(declaim (inline aset))
 
 (setf (symbol-function 'array-rank) (symbol-function 'c-array-rank)
       (symbol-function 'array-total-size) (symbol-function 'c-array-dim))
@@ -428,7 +425,7 @@
 		   (lreduce (lambda (y z)
 			      (if (tp<= x (car z)) y (cons (cdr z) y)))
 			    '#.(mapcar (lambda (x) (cons (cmp-norm-tp `(not (array ,(pop x)))) x))
-				       *array-type-info*)
+				       +array-type-info+)
 			    :initial-value nil))))))
 
 (defun array-elttype-propagator (f x)
@@ -483,3 +480,32 @@
 		 +array-types+)
 	t)))
 (declaim (inline array-eql-is-eq))
+
+(defun msdata-ref (d s)
+  (structure-ref1 d (fifth (assoc s (structure-ref1 d 7)))));FIXME 7
+
+(defmacro str-refset (x s n &optional (v nil vp))
+  (assert (and (constantp s) (constantp n)))
+  (let* ((s (eval s))(n (eval n))(?sd (eq s 's-data))
+	 (d (get s 's-data))
+	 (k (aref (if ?sd (msdata-ref d 'raw) (s-data-raw d)) n))
+	 (pos (aref (if ?sd (msdata-ref d 'slot-position) (s-data-slot-position d)) n))
+	 (l (nth k +array-type-info+))
+	 (cp (eq (car l) 'character))
+	 (v (when vp (if cp `(char-code ,v) v)))
+	 (res `(,(fifth l) (c-strstd-sself ,x) ,(ash pos (min 0 (- (1- (third l))))) ,(when vp t) ,v))
+	 (tp (car (last (nth n (if ?sd (msdata-ref d 'slot-descriptions) (s-data-slot-descriptions d))))))
+	 (res (if cp `(code-char ,res) res)))
+    (if (unless (eq tp t) tp) `(the ,tp ,res) res)))
+
+(defun *-propagator (f t1 t2 t3 t4)
+  (declare (ignore t1 t2))
+  (when (tp<= t3 #t(not null))
+    (tp-and t4
+	    (reduce 'tp-or
+		    (mapcar (lambda (x) (unless (eq (car x) 'character) (cmp-norm-tp (car x))));FIXME
+			    (remove f +array-type-info+ :test-not 'eq :key 'fifth))
+		    :initial-value nil))))
+(dolist (l (mapcar 'fifth +array-type-info+))
+  (setf (get l 'type-propagator) '*-propagator))
+
--- gcl27-2.7.0.orig/lsp/gcl_defstruct.lsp
+++ gcl27-2.7.0/lsp/gcl_defstruct.lsp
@@ -39,8 +39,8 @@
 (defun make-access-function (name conc-name no-conc type named include no-fun
 				  ;; from apply
 				  slot-name default-init slot-type read-only
-				  offset &optional predicate) 
-  (declare (ignore named default-init predicate no-fun))
+				  offset &optional predicate ost)
+  (declare (ignore named default-init predicate no-fun ost))
   (let ((access-function (if no-conc slot-name
 			   (intern (si:string-concatenate conc-name slot-name)))))
     (record-fn access-function 'defun '(t) slot-type)
@@ -216,7 +216,7 @@
                (t
                 (error "~S is an illegal structure slot option."
                          os))))))
-    (list slot-name default-init slot-type read-only offset)))
+    (list slot-name default-init slot-type read-only offset nil slot-type)))
 
 
 ;;; OVERWRITE-SLOT-DESCRIPTIONS overwrites the old slot-descriptions
@@ -240,12 +240,12 @@
 	       (when (not  (equal (normalize-type (or (caddr (car sds)) t))
 				 (normalize-type (or (caddr (car olds)) t))))
 		     (error "Type mismmatch for included slot ~a" (car sds)))
-		     (cons (list (caar sds)
-                           (cadar sds)
-                           (caddar sds)
-                           (cadddr (car sds))
-                           ;; The offset if from the old.
-                           (car (cddddr (car olds))))
+		     (cons (list* (caar sds)
+				  (cadar sds)
+				  (caddar sds)
+				  (cadddr (car sds))
+				  ;; The rest from the old.
+				  (cddddr (car olds)))
                      (overwrite-slot-descriptions news (cdr olds))))
               (t
                (cons (car olds)
@@ -644,14 +644,14 @@
 	   new-slot-descriptions
 	   (new-slot-descriptions ;(copy-list slot-descriptions)))
 	    (dolist (sd slot-descriptions (nreverse new-slot-descriptions))
-	      (if (and (consp sd) (eql (length sd) 5))
+	      (if (and (consp sd) (eql (length sd) 7))
 		(let* ((csd (car sd))
 		       (sym (when (or (constantp csd) (keywordp csd) (si::specialp csd)) 
 			      (make-symbol (symbol-name csd))))
 		       (nsd (if (or (constantp csd) (si::specialp csd))
 				(cons (intern (symbol-name csd) 'keyword) (cdr sd))
 			      sd)))
-		  (push (append nsd (list sym)) new-slot-descriptions)
+		  (push (append (butlast nsd 2) (list sym (car (last nsd)))) new-slot-descriptions)
 		  (when sym
 		    (setf (car sd) sym)))
 		(push sd new-slot-descriptions)))))
@@ -687,7 +687,7 @@
 			   (check-type x ,ctp)
 			   (the ,(or (not st) st)
 				,(ecase tp
-					((nil) `(str-ref x ',name ,offset))
+					((nil) `(str-refset x ',name ,offset));FIXME possibly macroexpand here, include?
 					(list `(let ((c (nthcdr ,offset x))) (check-type c cons) (car c)));(list-nth ,offset x))
 					(vector `(aref x ,offset)))))))
 		   slot-descriptions)
--- gcl27-2.7.0.orig/lsp/gcl_s.lsp
+++ gcl27-2.7.0/lsp/gcl_s.lsp
@@ -2,7 +2,7 @@
 (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
+(si::import-internal 'si::(\| & ^ ~ c+ c* << >> object double end-shft std-instance
 			   c-object-== c-fixnum-== c-float-== c-double-== c-fcomplex-== c-dcomplex-== fcomplex dcomplex
 			   string-concatenate lit seqind seqbnd fixnum-length char-length cref address nani short int
 			   cnum unsigned-char unsigned-short unsigned-int
@@ -25,6 +25,7 @@
 	     (:object     ""                     t)
 
 ;	     (:stdesig    ""                     (or symbol string character))
+	     (:strstd     ""                     (or structure std-instance))
 	     (:matrix     ""                     matrix)
 	     (:adjvector  ""                     adjustable-vector)
 	     (:adjarray   ""                     adjustable-array)
@@ -71,7 +72,8 @@
 					   "({fixnum _t;unsigned char *p1=(void *)(((fixnum *)" (:fixnum x) ")+" (:fixnum o) "),*p2=(void *)&_t,*pe=p1+sizeof(fixnum);for (;p1<pe;) *p2++=*p1++;_t;}) : "
 					   "((fixnum *)" (:fixnum x) ")[" (:fixnum o) "])"))
 				 `(if s (lit ,x "(((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]=" (,x y) ")")
-				      (lit ,x "((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]"))))) +ks+)))
+				      (lit ,x "((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]")))))
+		 +ks+)))
   (defmacro mfff nil
    `(progn
       (idefun address (x) (lit :fixnum "((fixnum)" (:object x) ")"))
--- gcl27-2.7.0.orig/lsp/gcl_setf.lsp
+++ gcl27-2.7.0/lsp/gcl_setf.lsp
@@ -390,7 +390,7 @@
     (list `(setf (nth ,index ,struct) ,newvalue))
 ;    (list `(si:rplaca-nthcdr ,struct ,index ,newvalue))
     (vector `(si::elt-set ,struct ,index ,newvalue))
-    (t `(si::structure-set ,struct ',type ,index ,newvalue))))
+    (t `(str-refset ,struct ',type ,index ,newvalue))));si::structure-set
 
 (defun setf-expand (l env)
   (cond ((endp l) nil)
--- gcl27-2.7.0.orig/lsp/gcl_sharp.lsp
+++ gcl27-2.7.0/lsp/gcl_sharp.lsp
@@ -53,7 +53,7 @@
       (aset1 x i (patch-sharp (row-major-aref x i)))))
    (structure
     (let ((d (structure-def x))) 
-      (dotimes (i (structure-length x) x)
+      (dotimes (i (structure-length d) x)
 	(declare (fixnum i))
 	(structure-set x d i (patch-sharp (structure-ref x d i))))))
    (spice (let* ((y (gethash1 x (context-spice *sharp-eq-context*)))
--- gcl27-2.7.0.orig/makefile
+++ gcl27-2.7.0/makefile
@@ -52,12 +52,10 @@ gprof_objs: $(addprefix $(PORTDIR)/,$(ad
 $(PORTDIR)/saved_gcl_gprof: $(PORTDIR)/saved_gcl
 	mkdir -p gprof
 	for i in o lsp cmpnew xgcl-2; do $(MAKE) -C $$i gprof_objs; done
-	cp cmpnew/gcl_cmpnopt.lsp.saved_gcl cmpnew/gcl_cmpnopt.lsp
 	$(MAKE) -C unixport $(@F)
 
 $(PORTDIR)/saved_ansi_gcl_gprof: $(PORTDIR)/saved_gcl_gprof $(PORTDIR)/saved_ansi_gcl
 	for i in mod pcl clcs; do $(MAKE) -C $$i gprof_objs; done
-	cp cmpnew/gcl_cmpnopt.lsp.saved_ansi_gcl cmpnew/gcl_cmpnopt.lsp
 	$(MAKE) -C unixport $(@F)
 
 ASRC:=$(shell ls -1 o/*.c o/*.d o/*.h h/*.h lsp/*.lsp cmpnew/*.lsp mod/*.lsp pcl/*sp clcs/*sp xgcl-2/*p) #o/*.d o/*.h h/*.h
@@ -95,7 +93,6 @@ $(PORTDIR)/saved_pre_gcl: $(HDIR)cmpincl
 	(cd $(BINDIR); $(MAKE) all)
 	$(MAKE) mpfiles
 	rm -f o/cmpinclude.h ; cp h/cmpinclude.h o
-	rm -f cmpnew/gcl_cmpnopt.lsp
 	(cd $(ODIR); $(MAKE) all)
 	$(MAKE) $<
 	rm -f o/cmpinclude.h ; cp h/cmpinclude.h o
@@ -117,7 +114,6 @@ $(PORTDIR)/saved_gcl2: $(PORTDIR)/saved_
 
 $(PORTDIR)/saved_gcl: $(PORTDIR)/saved_gcl2 $(HDIR)cmpinclude.h
 	cd $(@D) && echo '(time (load "boot.lisp"))' | ./$(<F) && $(MAKE) $(@F)
-	cp cmpnew/gcl_cmpnopt.lsp cmpnew/gcl_cmpnopt.lsp.saved_gcl
 	echo '(si::do-recomp t)' | $@ && cd $(@D) && $(MAKE) $(@F)
 
 $(PORTDIR)/saved_mod_gcl: $(PORTDIR)/saved_gcl
@@ -132,7 +128,6 @@ $(PORTDIR)/saved_pcl_gcl: $(PORTDIR)/sav
 
 $(PORTDIR)/saved_ansi_gcl: $(PORTDIR)/saved_pcl_gcl
 	(cd $(CLCSDIR); $(MAKE) clean; $(MAKE) all)
-	cp cmpnew/gcl_cmpnopt.lsp cmpnew/gcl_cmpnopt.lsp.saved_ansi_gcl
 	cd $(@D) && $(MAKE) $(@F)
 
 ansi-tests/test_results: $(PORTDIR)/saved_ansi_gcl
@@ -402,12 +397,12 @@ $(HDIR)mstdint.h:
 
 $(HDIR)mcompdefs.h: $(HDIR)compdefs.h $(HDIR)new_decl.h
 	$(AWK) 'BEGIN {print "#include \"include.h\"";print "#include \"page.h\"";print "---"} {a=$$1;gsub("\\.\\.\\.","",a);print "\"#define " $$1 "\" " a}' $< |\
-	$(CC) -E -P -I./$(HDIR) - |\
+	$(CC) $(CFLAGS) -E -P -I./$(HDIR) - |\
 	$(AWK) '/^\-\-\-$$/ {i=1;next} {if (!i) next} {gsub("\"","");print}' >$@
 
 $(HDIR)cmpinclude.h: $(HDIR)mcompdefs.h $(CMPINCLUDE_FILES) $(HDIR)config.h $(HDIR)cmponly_last.h
 	cp $< $(@F)
-	cat $(CMPINCLUDE_FILES) | $(CC) -E -I./$(HDIR) - | $(AWK) '/^# |^$$|^#pragma/ {next}{print}' >> $(@F)
+	cat $(CMPINCLUDE_FILES) | $(CC) $(CFLAGS) -E -I./$(HDIR) - | $(AWK) '/^# |^$$|^#pragma/ {next}{print}' >> $(@F)
 	cat $(HDIR)cmponly_last.h >>$(@F)
 	./xbin/move-if-changed mv $(@F) $@
 	./xbin/move-if-changed cp $@ o/$(@F)
--- gcl27-2.7.0.orig/o/cfun.c
+++ gcl27-2.7.0/o/cfun.c
@@ -213,6 +213,15 @@ make_special_form_internal(char *s,void
 }
 
 object
+make_si_special_form_internal(char *s,void *f)
+{
+	object x;
+	x = make_si_ordinary(s);
+	x->s.s_sfdef = (fixnum)f;
+	return(x);
+}
+
+object
 make_macro_internal(char *s, void (*f)())
 {
 	object x;
--- gcl27-2.7.0.orig/o/file.d
+++ gcl27-2.7.0/o/file.d
@@ -770,19 +770,8 @@ int line_length;
 	object strng, strm;
 	vs_mark;
 
-	strng = alloc_object(t_string);
-	strng->st.st_hasfillp = TRUE;
-	strng->st.st_adjustable = TRUE;
-	/* strng->st.tt= */strng->st.st_elttype = aet_ch;
-	/* strng->st.st_eltsize = elt_size(aet_ch); */
-	strng->st.st_rank = 1;
-	SET_ADISP(strng,Cnil);
-	strng->st.st_dim = line_length;
+	strng = alloc_string(line_length);
 	strng->st.st_fillp = 0;
-	strng->st.st_self = NULL;
-		/*  For GBC not to go mad.  */
-	vs_push(strng);
-		/*  Saving for GBC.  */
 	strng->st.st_self = alloc_relblock(line_length);
 	strm = alloc_object(t_stream);
 	strm->sm.tt=strm->sm.sm_mode = (short)smm_string_output;
--- gcl27-2.7.0.orig/o/gbc.c
+++ gcl27-2.7.0/o/gbc.c
@@ -478,7 +478,7 @@ mark_object_array(object *o,object *oe)
 static void
 mark_object1(object x) {
 
-  fixnum i,j=0;/*FIXME*/
+  fixnum i,j;
 
   if (is_marked_or_free(x))
     return;
@@ -555,43 +555,20 @@ mark_object1(object x) {
 
   case t_simple_vector:
   case t_simple_bitvector:
+  case t_simple_string:
   case t_vector:
   case t_bitvector:
+  case t_string:
 
-    switch(j ? j : (enum aelttype)x->v.v_elttype) {
-
-    case aet_lf:
-      j= sizeof(longfloat)*x->v.v_dim;
-      if ((COLLECT_RELBLOCK_P) &&  (void *)x->v.v_self>=(void *)heap_end)
-	rb_pointer=PCEI(rb_pointer,sizeof(double));		/*FIXME GC space violation*/
-      break;
-
-    case aet_bit:
-      j=ceil(BV_OFFSET(x)+x->bv.bv_dim,BV_ALLOC)*sizeof(*x->bv.bv_self);
-      break;
-
-    case aet_char:
-    case aet_uchar:
-      j=sizeof(char)*x->v.v_dim;
-      break;
-
-    case aet_short:
-    case aet_ushort:
-      j=sizeof(short)*x->v.v_dim;
-      break;
-
-    case aet_object:
-      if (ADISP(x)->c.c_car==Cnil)
-	mark_object_array(x->v.v_self,x->v.v_self+x->v.v_dim);
+    if (x->v.v_elttype==aet_object && ADISP(x)->c.c_car==Cnil)
+      mark_object_array(x->v.v_self,x->v.v_self+x->v.v_dim);
 
-    default:
-      j=sizeof(fixnum)*x->v.v_dim;
+    j=x->v.v_eltsize ? (1<<(x->v.v_eltsize-1)) : x->v.v_eltsize;
 
-    }
+    if ((COLLECT_RELBLOCK_P) && (void *)x->v.v_self>=(void *)heap_end && j>sizeof(long))
+      rb_pointer=PCEI(rb_pointer,j); /*FIXME GC space violation*/
 
-  case t_simple_string:
-  case t_string:/*FIXME*/
-    j=j ? j : x->st.st_dim;
+    j=j ? j*x->v.v_dim : ceil(BV_OFFSET(x)+x->bv.bv_dim,BV_ALLOC)*sizeof(*x->bv.bv_self);
 
     if (ADISP(x)->c.c_car==Cnil)
       MARK_LEAF_DATA(x,x->v.v_self,j);
--- gcl27-2.7.0.orig/o/let.c
+++ gcl27-2.7.0/o/let.c
@@ -363,7 +363,7 @@ gcl_init_let(void)
 	make_special_form("LET", Flet);
 	make_special_form("LET*", FletA);
 	make_special_form("MULTIPLE-VALUE-BIND", Fmultiple_value_bind);
-	make_si_function("COMPILER-LET", Fcompiler_let);
+	make_si_special_form("COMPILER-LET", Fcompiler_let);
 	make_special_form("FLET",Fflet);
 	make_special_form("LABELS",Flabels);
 	make_special_form("MACROLET",Fmacrolet);
--- gcl27-2.7.0.orig/o/main.c
+++ gcl27-2.7.0/o/main.c
@@ -290,6 +290,9 @@ get_gc_environ(void) {
   }
 
   multiprocess_memory_pool=getenv("GCL_MULTIPROCESS_MEMORY_POOL");
+  if (multiprocess_memory_pool &&
+      (*multiprocess_memory_pool=='t' || *multiprocess_memory_pool=='T'))/*GCL 2.6 compatability*/
+    multiprocess_memory_pool=getenv("HOME");
 
   wait_on_abort=0;
   if ((e=getenv("GCL_WAIT_ON_ABORT")))
--- gcl27-2.7.0.orig/pcl/makefile
+++ gcl27-2.7.0/pcl/makefile
@@ -20,6 +20,9 @@ SETUP='(load "../clcs/package.lisp")(loa
 	'(setq compiler::*assert-ftype-proclamations* t)' \
 	'(setq compiler::*tmp-dir* "" si::*disable-recompile* t)'
 
+DINLH:='(compile nil (quote (lambda (x) (declare (si::std-instance x)) (class-of x))))' \
+       '(compiler::dump-inl-hash "../cmpnew/gcl_cmpnopt_pcl.lsp")'
+
 LISP?=../unixport/saved_mod_gcl
 APPEND=../xbin/append
 
@@ -41,7 +44,7 @@ $(addsuffix .c,$(AFILES)) $(addsuffix .d
 	$(addsuffix .h,$(AFILES)): \
 	$(addsuffix .lisp,$(FILES))
 	cp ../h/cmpinclude.h .
-	echo ${SETUP} '(pcl::compile-pcl)' | $(LISP)
+	echo ${SETUP} '(pcl::compile-pcl)' ${DINLH}  | $(LISP)
 
 %.o: %.c %.h %.data
 	$(CC) $(CFLAGS) -c $< -o $@
@@ -62,7 +65,7 @@ remake-sys-files:
 		| $(LISP) ../unixport/ $(LISPFLAGS)
 	$(MAKE) clean
 	$(MAKE)
-	echo $(SETUP) '(pcl::load-pcl)(si::all-conflicts)(compiler::dump-inl-hash "../cmpnew/gcl_cmpnopt.lsp")' \
+	echo $(SETUP) '(pcl::load-pcl)(si::all-conflicts)' \
 		| $(LISP) ../unixport/ $(LISPFLAGS)
 
 tar:
--- gcl27-2.7.0.orig/pcl/sys-package.lisp
+++ gcl27-2.7.0/pcl/sys-package.lisp
@@ -14,13 +14,13 @@
 ;;; Definitions for package ITERATE of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "ITERATE")
- (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("COMMON-LISP" "WALKER")))
+ (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("WALKER" "COMMON-LISP")))
 
 ;;; Definitions for package PCL of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "PCL")
  (COMMON-LISP::MAKE-PACKAGE
-  "PCL" :USE '("COMMON-LISP" "ITERATE" "WALKER" "CSTRUCT")))
+  "PCL" :USE '("CSTRUCT" "WALKER" "ITERATE" "COMMON-LISP")))
 
 ;;; Definitions for package SLOT-ACCESSOR-NAME of type EXPORT
 (COMMON-LISP::IMPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
@@ -2133,90 +2133,89 @@
    PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION PCL::LEGAL-DOCUMENTATION-P
    PCL::PRECEDENCE PCL::MAKE-N-N-ACCESSOR-DFUN COMMON-LISP::OTHERWISE
    PCL::.PV-OFFSET. PCL::ACCESSOR-DFUN-INFO-
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PLIST)|
-   PCL::|(FAST-WRITER-METHOD PLIST-MIXIN PLIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-WRITER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LAMBDA-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
-   PCL::RECORD-DEFINITION PCL::EARLY-GF-P PCL::SPLIT-DECLARATIONS
-   PCL::USE-DISPATCH-DFUN-P PCL::DFUN-INFO-WRAPPER1
-   PCL::*NORMALIZE-TYPE
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMP-ENV)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOAD-ENV)| PCL::OBJECT-FORM
-   PCL::FUNCALLABLE-STANDARD-CLASS-SIMPLE-TYPEP-FN
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-WRITER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-WRITER-METHOD PLIST-MIXIN PLIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PLIST)| PCL::RECORD-DEFINITION
+   PCL::EARLY-GF-P PCL::SPLIT-DECLARATIONS PCL::USE-DISPATCH-DFUN-P
+   PCL::DFUN-INFO-WRAPPER1 PCL::*NORMALIZE-TYPE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOAD-ENV)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMP-ENV)| PCL::OBJECT-FORM
    PCL::FUNCALLABLE-STANDARD-OBJECT-SIMPLE-TYPEP-FN
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::FUNCALLABLE-STANDARD-CLASS-SIMPLE-TYPEP-FN
    PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFORM)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
    PCL::%STD-INSTANCE- PCL::.QUALIFIERS. PCL::REMOVE-NAMED-METHOD
    PCL::CACHE-FIELD PCL::INSTANCE-SLOTDS PCL::FSC
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT TYPE)|
    PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION TYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT TYPE)| PCL::GCL_PCL_SLOTS
-   PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::INSTANCE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
+   PCL::GCL_PCL_SLOTS PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::INSTANCE
    COMMON-LISP::SIMPLE-CONDITION
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NKEYS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION WRITERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION READERS)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION READERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION WRITERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NKEYS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
    PCL::DEFINITIONS PCL::DFUN-INFO-WRAPPER0 PCL::REMTAIL
    PCL::SPLIT-DECLARATIONS-MOVING-IGNORES PCL::MAKE-PV-TABLE
    COMMON-LISP::FLOOR PCL::GET-SYMBOL PCL::METHOD-CALL-P
    PCL::|__si::MAKE-INITIAL|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT MAX-LOCATION)|
-   PCL::|(FAST-WRITER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ALLOCATION)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOCATION)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FAST-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FUNCTION)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DOCUMENTATION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FUNCTION)| PCL::PARAMETER
-   PCL::PARAMETERS PCL::BUILT-IN
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ALLOCATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
+   PCL::|(FAST-WRITER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT MAX-LOCATION)| PCL::PARAMETERS
+   PCL::PARAMETER PCL::BUILT-IN
    PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
-   PCL::FIRST-P PCL::DFUN-INFO-ACCESSOR-TYPE CSTRUCT::C-FLOAT-DOUBLE->
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
+   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 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 CSTRUCT::C-SET-HASHTABLE-SELF
    PCL::METHOD-CLASS-NAME COMMON-LISP::INTERACTIVE-STREAM-P PCL::CAM
-   PCL::DEFSTRUCT-P PCL::ONE-ORDER-P PCL::ONE-INDEX-P
+   PCL::DEFSTRUCT-P PCL::ONE-INDEX-P PCL::ONE-ORDER-P
    PCL::INTERN-FUNCTION-NAME PCL::SLOTD PCL::INSTANCE-BOUNDP
    PCL::INSTANCE-WRITER CSTRUCT::C-FLOAT-FCOMPLEX-==
    CSTRUCT::C-FLOAT-DCOMPLEX-== PCL::KNOWN-TYPE
@@ -2226,46 +2225,46 @@
    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::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)|
    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
-   PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::ARG PCL::ONE-CLASS-
-   PCL::ONE-CLASS COMMON-LISP::WITH-INPUT-FROM-STRING PCL::SMC-CLASS
+   PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::ARG PCL::ONE-CLASS
+   PCL::ONE-CLASS- COMMON-LISP::WITH-INPUT-FROM-STRING PCL::SMC-CLASS
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT MASK)| PCL::OLD-CLASS
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LINE-SIZE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SIZE)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SIZE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LINE-SIZE)|
    PCL::MAKE-EMF-FROM-METHOD PCL::%SET-CCLOSURE PCL::INITKEYS
    PCL::SDFUN-METHOD PCL::WRAPPERS-MISMATCH-P PCL::GCL_PCL_DLISP
-   PCL::METHOD-FN-NAME PCL::METHOD-NAME PCL::NEW-CLASS PCL::METACLASS
+   PCL::METHOD-NAME PCL::METHOD-FN-NAME PCL::METACLASS PCL::NEW-CLASS
    PCL::INDEX PCL::REQUIRED-ARGS+REST-ARG PCL::INSTANCE-READER
    PCL::PCL-CLASS PCL::BUILT-IN-CLASS-WRAPPER COMMON-LISP::EQL
    PCL::READER-NAME PCL::RESET-CLASS-INITIALIZE-INFO
-   PCL::ALLOCATE-STANDARD-INSTANCE PCL::ALLOCATE-STRUCTURE-INSTANCE
+   PCL::ALLOCATE-STRUCTURE-INSTANCE PCL::ALLOCATE-STANDARD-INSTANCE
    PCL::INITIAL COMMON-LISP::MASK-FIELD PCL::COMPILE-IIS-FUNCTIONS
    COMMON-LISP::COMPUTE-RESTARTS PCL::METHOD-LL->GENERIC-FUNCTION-LL
-   PCL::MAKE-FGEN PCL::|(BOUNDP SOURCE)| PCL::PV-WRAPPERS-FROM-ALL-ARGS
-   PCL::PV-WRAPPERS-FROM-PV-ARGS PCL::EARLY-CLASS-SLOTDS
+   PCL::MAKE-FGEN PCL::|(BOUNDP SOURCE)| PCL::PV-WRAPPERS-FROM-PV-ARGS
+   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::EARLY-CLASS-SLOTDS
    PCL::VARIABLE-CLASS PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FIELD)|
    PCL::|ARG-INFO SLOT10| PCL::CLASS-DECLARATIONS PCL::SOURCE
    PCL::GET-NEW-FUNCTION-GENERATOR COMMON-LISP::*DEBUG-IO* PCL::APPLYP
    PCL::CACHE-VECTOR-REF PCL::FUNCTION-P
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)|
-   PCL::|(FAST-WRITER-METHOD CLASS NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DFUN-STATE)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NAME)|
    PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NAME)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION NAME)|
+   PCL::|(FAST-WRITER-METHOD CLASS NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::NAME)|
    PCL::STD-INSTANCE-P SYSTEM::VOID PCL::SECTION PCL::CVECTOR
    PCL::MAKE-DUMMY-VAR PCL::UPDATE-GFS-OF-CLASS
    COMMON-LISP::RANDOM-STATE-P PCL::FINALIZEP PCL::|__si::MAKE-CACHING|
@@ -2319,21 +2318,21 @@
    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::TRANSFORMS PCL::TRANSFORM PCL::NAME-DECL
+   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::CLAUSE
-   PCL::CLASSES PCL::*NAME->CLASS->SLOTD-TABLE*
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLASSES
+   PCL::CLAUSE PCL::*NAME->CLASS->SLOTD-TABLE*
    PCL::EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::INITARGS
-   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
    PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER| PCL::PLIST-P
+   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::PLIST-P
    COMMON-LISP::SET-EXCLUSIVE-OR COMMON-LISP::GENSYM
    PCL::|(WRITER ARG-INFO)| COMMON-LISP::REALPART
    CSTRUCT::C-SET-PATHNAME-DEVICE PCL::PLIST PCL::|(WRITER OPERATOR)|
@@ -2355,8 +2354,8 @@
    PCL::CLASS-SLOT-P PCL::DEFSTRUCT-ACCESSOR-SYMBOL PCL::READERS-INIT
    COMMON-LISP::*PRINT-PRETTY* PCL::|(SETF DOCUMENTATION)|
    PCL::NON-REQUIRED-ARGS PCL::EXISTING-P
-   PCL::FUNCALLABLE-INSTANCE-DATA PCL::EARLY-CLASS-SIZE PCL::FROM-CACHE
-   PCL::FREE-CACHE PCL::CHECK-QUALIFIERS COMMON-LISP::*QUERY-IO*
+   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*
    CSTRUCT::*SHORT PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
@@ -2369,22 +2368,23 @@
    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 DEFINITION-SOURCE-MIXIN|
-   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
    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 CSTRUCT::C-SYMBOL-NAME PCL::CANONICAL-SLOT
    PCL::|(WRITER CLASS-EQ-SPECIALIZER)| PCL::DEFCONSTRUCTOR
    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-FORM-LIST
-   PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
-   PCL::INITIALIZE-INFO-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
+   PCL::INITIAL-
    PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
-   PCL::|(READER INITARGS)| COMMON-LISP::BOOLE-C2 PCL::RENEW-SYS-FILES
+   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-INITARGS-FORM-LIST
+   PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
+   PCL::INITIALIZE-FORM-LIST PCL::|(READER INITARGS)|
+   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 CSTRUCT::C-SPICE-DUMMY
@@ -2393,7 +2393,7 @@
    COMMON-LISP::RESTART-CASE PCL::PV-BINDING1 COMMON-LISP::PAIRLIS
    PCL::*ASV-BOUNDPS* PCL::EXTRA-P
    PCL::|(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)|
-   PCL::INITIALIZE-INFO-CACHED-SLOTS PCL::INITIALIZE-INFO-BOUND-SLOTS
+   PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::INITIALIZE-INFO-CACHED-SLOTS
    PCL::INITIALIZE-INITFNS COMMON-LISP::*PRINT-LINES* PCL::CPL
    PCL::LEGAL-SPECIALIZER-P PCL::INSTANCE-ACCESSOR-PARAMETER
    COMMON-LISP::STANDARD-CHAR-P PCL::CACHE-COUNT
@@ -2410,7 +2410,7 @@
    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::TMETHOD PCL::OMETHOD
+   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
    CSTRUCT::C-SYMBOL-DBIND PCL::.PV-TABLE. PCL::TOP
@@ -2423,16 +2423,16 @@
    PCL::ELSE PCL::OSTATE COMMON-LISP::TWO-WAY-STREAM
    PCL::*SLOTD-BOUNDP-FUNCTION-STD-P* PCL::|(READER ARG-INFO)|
    COMMON-LISP::BIT-VECTOR-P COMMON-LISP::TYPE-ERROR-DATUM
-   PCL::|(CALL REAL-GET-METHOD)| PCL::|(CALL REAL-REMOVE-METHOD)|
-   PCL::|(CALL REAL-ADD-METHOD)| PCL::ONE-INDEX-DFUN-INFO-CACHE
+   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
    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-SLOTS)|
-   PCL::|(SETF CLASS-DIRECT-SLOTS)| PCL::COMPUTE-LINE-SIZE
+   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
@@ -2440,26 +2440,26 @@
    COMMON-LISP::SPECIAL PCL::OCACHE PCL::NO-OF-INSTANCE-SLOTS
    PCL::INTERNAL-COUNT PCL::HOME-LOC PCL::|SYSTEM:S-DATA SLOT4|
    PCL::EARLY-FIND-CLASS-SYMBOL COMMON-LISP::DIGIT-CHAR-P
-   PCL::|COMMON-LISP::PATHNAME class predicate|
-   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
-   PCL::|COMMON-LISP::READTABLE class predicate|
-   PCL::|COMMON-LISP::PACKAGE class predicate|
-   PCL::|COMMON-LISP::HASH-TABLE class predicate|
-   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
-   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
-   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
-   PCL::|COMMON-LISP::STRING-STREAM class predicate|
-   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
-   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
-   PCL::|COMMON-LISP::FILE-STREAM class predicate|
-   PCL::|COMMON-LISP::STREAM class predicate|
-   PCL::|COMMON-LISP::ARRAY class predicate|
-   PCL::|COMMON-LISP::VECTOR class predicate|
-   PCL::|COMMON-LISP::STRING class predicate|
-   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
-   PCL::|COMMON-LISP::CHARACTER class predicate|
-   PCL::|COMMON-LISP::SYMBOL 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::NULL class predicate|
    PCL::|COMMON-LISP::CONS class predicate|
    PCL::|COMMON-LISP::LIST class predicate|
@@ -2720,11 +2720,61 @@
    PCL::|INITIALIZE-INFO SLOT3| PCL::XEROX-PATCHES
    PCL::LIST-LARGE-CACHES PCL::INVALID-WRAPPER-P
    CSTRUCT::C-SET-STRUCTURE-SELF
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|
+   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|
+   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
+   PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
+   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
+   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))| 
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
    PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
    PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
    PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
    PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
-   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| 
    PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
    PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
    PCL::|(FAST-METHOD DOCUMENTATION (T T))|
@@ -2757,56 +2807,6 @@
    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 COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
-   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|
-   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION 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::|(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 UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
-   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
-   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD 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 COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
-   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 :AFTER (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-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::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
@@ -2823,8 +2823,8 @@
    CSTRUCT::C-SET-CFDATA-SELF PCL::AKEY COMMON-LISP::LENGTH
    PCL::MAKE-DFUN-LAMBDA-LIST PCL::NEW-TYPE PCL::CMU-LOW PCL::OK
    CSTRUCT::C-SET-ARRAY-SELF PCL::PV-TABLES PCL::GCL_PCL_FAST_INIT
-   PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::ALIST-TAIL
-   PCL::KLIST-TAIL PCL::*DEFCLASS-TIMES*
+   PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::KLIST-TAIL
+   PCL::ALIST-TAIL PCL::*DEFCLASS-TIMES*
    PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
    COMMON-LISP::DO-EXTERNAL-SYMBOLS PCL::|INITIALIZE-INFO SLOT0|
    PCL::SLOTS-INIT COMMON-LISP::CHAR<= SYSTEM::C+
@@ -2841,8 +2841,8 @@
    PCL::LOCATION-RESERVED-P COMMON-LISP::++
    PCL::STRUCTURE-DIRECT-SLOT-DEFINITION COMMON-LISP::*GENSYM-COUNTER*
    PCL::COPY-STRUCTURE-OBJECT PCL::|(READER NAME)| PCL::.SPECIALIZERS.
-   PCL::*INLINE-IIS-INSTANCE-LOCATIONS-P* PCL::SET-CLASS-SLOT-VALUE-1
-   PCL::GET-CLASS-SLOT-VALUE-1 PCL::ENVIRONMENT
+   PCL::*INLINE-IIS-INSTANCE-LOCATIONS-P* PCL::GET-CLASS-SLOT-VALUE-1
+   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 CSTRUCT::C-SET-T-EMF
@@ -2887,38 +2887,38 @@
    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::SLOTS-KEY PCL::CLASS-KEY
+   COMMON-LISP::WITH-OUTPUT-TO-STRING PCL::CLASS-KEY PCL::SLOTS-KEY
    PCL::SLOT-VARS PCL::*PATHNAME-EXTENSIONS* COMMON-LISP::SHIFTF
    COMMON-LISP::RETURN PCL::.CALL. PCL::COPY-CONSTANT-VALUE
-   PCL::LONG-METHOD-COMBINATION PCL::LONG-METHOD-COMBINATION-FUNCTION
+   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* 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
-   PCL::PV-TABLE- PCL::PV-TABLE-P COMMON-LISP::BIT-NOR
+   PCL::PV-TABLE-P PCL::PV-TABLE- COMMON-LISP::BIT-NOR
    PCL::FIND-STRUCTURE-CLASS PCL::%SET-SVREF PCL::*THE-WRAPPER-OF-NULL*
    PCL::PRECOMPILE-DFUN-CONSTRUCTOR PCL::*THE-CLASS-ARRAY*
    PCL::|(FAST-INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
    PCL::INIT-TYPE
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
-   PCL::SO-P PCL::NEW-SUPPLIED-P PCL::*CASE-TABLE-LIMIT* PCL::RESULT
-   PCL::*THE-WRAPPER-OF-LIST* PCL::*THE-CLASS-SPECIALIZER*
-   PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
-   PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| PCL::SO-P
+   PCL::NEW-SUPPLIED-P PCL::*CASE-TABLE-LIMIT* PCL::RESULT
+   PCL::*THE-WRAPPER-OF-LIST* PCL::*THE-CLASS-EQL-SPECIALIZER*
    PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
-   PCL::*THE-CLASS-EQL-SPECIALIZER* CSTRUCT::LISP-TYPE PCL::DFUN-TYPE
+   PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
+   PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
+   PCL::*THE-CLASS-SPECIALIZER* CSTRUCT::LISP-TYPE PCL::DFUN-TYPE
    PCL::IMPROPER-LIST-HANDLER PCL::*SLOT-ACCESSOR-NAME-PACKAGE*
    PCL::|CACHE SLOT11| CSTRUCT::C-HASHTABLE-RHSIZE
    CSTRUCT::C-HASHTABLE-SIZE
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-METHODS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITIAL-METHODS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DECLARATIONS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DECLARATIONS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITIAL-METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-METHODS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
    PCL::COPY-ONE-INDEX-DFUN-INFO PCL::|(BOUNDP INITIALIZE-INFO)|
    PCL::ALL PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT* PCL::CACHING
@@ -2927,59 +2927,59 @@
    PCL::|(SETF SLOT-DEFINITION-INITFORM)| PCL::FIELD PCL::UNKNOWN
    PCL::MAKE-TWO-CLASS PCL::|(SETF SLOT-DEFINITION-TYPE)|
    PCL::*THE-CLASS-COMPLEX* PCL::READER/WRITER PCL::ALIST-ENTRY
-   PCL::*THE-CLASS-VECTOR* PCL::*THE-CLASS-CHARACTER*
-   PCL::*THE-CLASS-BIT-VECTOR* PCL::ORIGINAL SYSTEM::TP6
+   PCL::*THE-CLASS-BIT-VECTOR* PCL::*THE-CLASS-CHARACTER*
+   PCL::*THE-CLASS-VECTOR* PCL::ORIGINAL SYSTEM::TP6
    PCL::|CACHE SLOT10| PCL::|__si::MAKE-N-N|
-   PCL::|(SETF SLOT-DEFINITION-WRITERS)|
    PCL::|(SETF SLOT-DEFINITION-READERS)|
-   PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
-   PCL::*THE-CLASS-PLIST-MIXIN* PCL::*THE-CLASS-DOCUMENTATION-MIXIN*
+   PCL::|(SETF SLOT-DEFINITION-WRITERS)|
    PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
+   PCL::*THE-CLASS-DOCUMENTATION-MIXIN* PCL::*THE-CLASS-PLIST-MIXIN*
+   PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
    PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::REBOUND?
    PCL::*THE-WRAPPER-OF-FUNCTION* PCL::WRAPPER1
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PLIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LAMBDA-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PLIST)|
    COMMON-LISP::STRING-LESSP PCL::SLOT-INITARGS PCL::THING PCL::LMF
    PCL::EMIT-CONSTANT-VALUE PCL::KCL-LOW
    PCL::LONG-METHOD-COMBINATION-SIMPLE-TYPEP-FN
    PCL::|(BOUNDP DEFSTRUCT-CONSTRUCTOR)| PCL::FMF
    COMMON-LISP::CHAR-NOT-EQUAL PCL::MAKE-CLASS-PREDICATE-NAME
    PCL::COMPUTE-STD-CPL-PHASE-2 PCL::ADD-DIRECT-SUBCLASSES PCL::EMF
-   PCL::|(SETF SLOT-ACCESSOR-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-INITFUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-ALLOCATION)|
-   PCL::|(SETF SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-INTERNAL-READER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-BOUNDP-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-WRITER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-LOCATION)|
    PCL::|(SETF SLOT-DEFINITION-READER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-LOCATION)| PCL::CONSTRUCTORS
+   PCL::|(SETF SLOT-DEFINITION-WRITER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-BOUNDP-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-INTERNAL-READER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-ALLOCATION)|
+   PCL::|(SETF SLOT-DEFINITION-INITFUNCTION)|
+   PCL::|(SETF SLOT-ACCESSOR-FUNCTION)| PCL::CONSTRUCTORS
    PCL::*THE-CLASS-RATIO* PCL::MAKE-CHECKING-DFUN PCL::CLASS-NAMES
-   PCL::|(SETF SLOT-VALUE-USING-CLASS)|
    PCL::|(SETF SLOT-DEFINITION-CLASS)|
+   PCL::|(SETF SLOT-VALUE-USING-CLASS)|
    PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
    PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OBJECT)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)| PCL::AFTER
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)| PCL::AFTER
    PCL::RESET-PACKAGE PCL::CHECKING-MISS PCL::LINE
-   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM*
-   PCL::*THE-WRAPPER-OF-ECHO-STREAM*
-   PCL::*THE-WRAPPER-OF-TWO-WAY-STREAM*
-   PCL::*THE-WRAPPER-OF-STRING-STREAM*
-   PCL::*THE-WRAPPER-OF-CONCATENATED-STREAM*
+   PCL::*THE-WRAPPER-OF-STREAM* PCL::*THE-WRAPPER-OF-FILE-STREAM*
    PCL::*THE-WRAPPER-OF-BROADCAST-STREAM*
-   PCL::*THE-WRAPPER-OF-FILE-STREAM* PCL::*THE-WRAPPER-OF-STREAM*
-   PCL::CPL-ERROR PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
+   PCL::*THE-WRAPPER-OF-CONCATENATED-STREAM*
+   PCL::*THE-WRAPPER-OF-STRING-STREAM*
+   PCL::*THE-WRAPPER-OF-TWO-WAY-STREAM*
+   PCL::*THE-WRAPPER-OF-ECHO-STREAM*
+   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM* PCL::CPL-ERROR
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
    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
@@ -2987,40 +2987,39 @@
    PCL::COMPUTE-STD-CPL-PHASE-1 PCL::UNPARSED-SPECIALIZERS
    COMMON-LISP::LISP-IMPLEMENTATION-VERSION PCL::OWNER
    PCL::MAKE-MODULES PCL::CACHING-P CSTRUCT::C-HASHTABLE-SELF
-   COMMON-LISP::FIND
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ALLOCATION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LOCATION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FAST-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-DEFINITION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   COMMON-LISP::FIND PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   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* CSTRUCT::C-SET-STREAM-FD
    CSTRUCT::C-PACKAGE-SHADOWINGS PCL::*THE-WRAPPER-OF-STRING*
-   SYSTEM::TP5 PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)|
+   SYSTEM::TP5 PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-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::|(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*
    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-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION :FUNCTION :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-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-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-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 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
@@ -3030,19 +3029,19 @@
    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::DO-METHODS PCL::NO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
+   PCL::NO-METHODS PCL::DO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
    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-PATHNAME*
-   PCL::*THE-WRAPPER-OF-LOGICAL-PATHNAME* PCL::*THE-WRAPPER-OF-PACKAGE*
-   PCL::*THE-WRAPPER-OF-RANDOM-STATE* SYSTEM::TP4
-   COMMON-LISP::MACROEXPAND PCL::MAKE-SHARED-INITIALIZE-FORM-LIST
-   PCL::INITIALIZATION-ARGUMENTS COMMON-LISP::SHORT-FLOAT
-   PCL::*THE-CLASS-SEQUENCE* 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*
+   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::*THE-WRAPPER-OF-RANDOM-STATE*
+   PCL::*THE-WRAPPER-OF-PACKAGE* PCL::*THE-WRAPPER-OF-LOGICAL-PATHNAME*
+   PCL::*THE-WRAPPER-OF-PATHNAME* SYSTEM::TP4 COMMON-LISP::MACROEXPAND
+   PCL::MAKE-SHARED-INITIALIZE-FORM-LIST PCL::INITIALIZATION-ARGUMENTS
+   COMMON-LISP::SHORT-FLOAT PCL::*THE-CLASS-SEQUENCE*
+   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*
    CSTRUCT::C-SET-READTABLE-CASE PCL::.CACHE.
    PCL::ACCESSOR-SET-SLOT-VALUE
    PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
@@ -3052,41 +3051,42 @@
    COMMON-LISP::BIT-ORC1 PCL::FILE
    PCL::|(BOUNDP DEFSTRUCT-ACCESSOR-SYMBOL)| PCL::NEXT-METHOD-P-BODY
    CSTRUCT::C-FLOAT-FLOAT->
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)| PCL::MIF-KEY
-   COMMON-LISP::IMAGPART PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD*
-   PCL::*THE-CLASS-METHOD* PCL::*THE-CLASS-STANDARD-METHOD*
-   PCL::*THE-CLASS-STANDARD-READER-METHOD*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)| PCL::MIF-KEY
+   COMMON-LISP::IMAGPART PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD*
    PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
-   PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD* COMMON-LISP::CHAR-DOWNCASE
+   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
    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::EMF-FUNCALL PCL::FMC-FUNCALL SYSTEM::TP3 PCL::SMC
-   PCL::PV-TABLE-SLOT-NAME-LISTS PCL::MAKE-FINAL-ACCESSOR-DFUN
-   PCL::MAKE-FINAL-CHECKING-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN
-   PCL::MAKE-FINAL-CACHING-DFUN PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN
+   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-ONE-INDEX-ACCESSOR-DFUN PCL::MODULE-LOAD-ENV
-   PCL::MODULE-COMP-ENV PCL::LOAD-DEFMETHOD-INTERNAL PCL::SETQS
+   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)|
    CSTRUCT::C-SET-FUNCTION-VV PCL::*LAZY-DFUN-COMPUTE-P*
-   PCL::SORT-METHODS PCL::*THE-CLASS-HASH-TABLE*
-   PCL::*THE-CLASS-READTABLE* COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS
+   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::SET-VAL PCL::GET-VAL CSTRUCT::C-PATHNAME-DEVICE
+   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-II-METH PCL::STD-SI-METH PCL::STD-MI-METH
+   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
@@ -3129,17 +3129,17 @@
    PCL::PRECOMPILE-INITIALIZE-INSTANCE-SIMPLE PCL::*EMPTY-PV*
    PCL::SYSTEM-BINARY-FILES
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::FUN-VALUES)|
-   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-FINAL-DFUN-INTERNAL
+   PCL::MAKE-FINAL-DFUN-INTERNAL PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL
    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
    CSTRUCT::C-SET-T-ST PCL::METHOD2 PCL::*ALL-PV-TABLE-LIST*
    PCL::FSC-INSTANCE-SLOTS PCL::SORTER PCL::NEW-DEFINITION
    CSTRUCT::C-STREAM-INT CSTRUCT::C-STREAM-FP PCL::OTYPE PCL::SUBFORM
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
-   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
+   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
-   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)| PCL::NTYPE
+   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| PCL::NTYPE
    PCL::POS-FORM COMMON-LISP::MAPLIST COMMON-LISP::FILE-AUTHOR
    PCL::FSC-INSTANCE-CLASS PCL::EMIT-READER/WRITER-FUNCTION PCL::OUTER
    PCL::PV-TABLE-SYMBOL PCL::PV-INDEX
@@ -3152,22 +3152,22 @@
    PCL::REQUIRED
    PCL::|(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
    PCL::*UMI-COMPLETE-CLASSES*
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONSTRUCTORS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-DESCRIPTIONS)| 
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT RECOMP-REASONS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-CLASS SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-CLASS DIRECT-SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITIAL-METHODS)|
-   PCL::|(FAST-READER-METHOD GENERIC-FUNCTION INITIAL-METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DECLARATIONS)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DECLARATIONS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHODS)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT OPTIONS)|
    PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION OPTIONS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OPTIONS)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHODS)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DECLARATIONS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DECLARATIONS)|
+   PCL::|(FAST-READER-METHOD GENERIC-FUNCTION INITIAL-METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITIAL-METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-CLASS DIRECT-SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-CLASS SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT RECOMP-REASONS)|
+   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 CSTRUCT::C-T-MHASFILLP
    PCL::GF-DFUN-INFO PCL::POP-INTO
@@ -3181,129 +3181,127 @@
    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 SLOT-OBJECT PLIST)|
-   PCL::|(FAST-READER-METHOD PLIST-MIXIN PLIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS CAN-PRECEDE-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
    PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION ARGUMENTS-LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS CAN-PRECEDE-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-READER-METHOD PLIST-MIXIN PLIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PLIST)|
    CSTRUCT::C-SET-STREAM-OBJECT1 PCL::FORWARD-CLASS PCL::SAUT-NOT-EQL
    COMMON-LISP::PROVIDE PCL::SLOT-REGS
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)| PCL::BY
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)| PCL::BY
    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-OBJECT DEFSTRUCT-FORM)|
-   PCL::|(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFORM)|
    PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFORM)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
    PCL::WITH-EQ-HASH-TABLE
-   PCL::|(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
-   PCL::|(FAST-READER-METHOD CLASS-EQ-SPECIALIZER OBJECT)|
-   PCL::|(FAST-READER-METHOD CLASS-PROTOTYPE-SPECIALIZER OBJECT)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT OBJECT)|
    PCL::|(FAST-READER-METHOD EQL-SPECIALIZER OBJECT)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
-   PCL::|(FAST-READER-METHOD SPECIALIZER TYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PROTOTYPE)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS PROTOTYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION TYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OBJECT)|
+   PCL::|(FAST-READER-METHOD CLASS-PROTOTYPE-SPECIALIZER OBJECT)|
+   PCL::|(FAST-READER-METHOD CLASS-EQ-SPECIALIZER OBJECT)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
+   PCL::|(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)|
    PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION TYPE)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS PROTOTYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PROTOTYPE)|
+   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 CSTRUCT::C-SET-T-E
    CSTRUCT::C-SET-HASHTABLE-TEST CSTRUCT::C-T-MWRITABLE PCL::CONVERTED
    PCL::STD-INSTANCE-WRAPPER
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT NKEYS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITERS)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION WRITERS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT READERS)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION READERS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
    PCL::|(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION READERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION WRITERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT NKEYS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
    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 SLOT-OBJECT MAX-LOCATION)|
-   PCL::|(FAST-READER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
-   PCL::|(FAST-READER-METHOD TRACED-METHOD FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ALLOCATION)|
-   PCL::|(FAST-READER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
-   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT READER-FUNCTION)| 
-   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOCATION)|
-   PCL::|(FAST-READER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT FAST-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD FAST-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
-   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-DEFINITION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DOCUMENTATION)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
    PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DOCUMENTATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-DEFINITION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD FAST-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ALLOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
+   PCL::|(FAST-READER-METHOD TRACED-METHOD FUNCTION)|
+   PCL::|(FAST-READER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT MAX-LOCATION)|
    PCL::DIRECT-SLOTDS PCL::MAKE-SHORT-METHOD-COMBINATION
    PCL::PLIST-MIXIN COMMON-LISP::SIMPLE-VECTOR PCL::CALL-SPEC
    PCL::*ENABLE-EMF-CALL-TRACING-P* PCL::CM-ARGS1
    PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-CLASS)|
    PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
-   SYSTEM::OBJECT PCL::ARGUMENTS PCL::WRITER PCL::CACHE-NLINES
-   PCL::*SLOTD-UNSUPPLIED* COMMON-LISP::MACRO-FUNCTION
-   PCL::DO-STANDARD-DEFSETF PCL::|ARG-INFO SLOT9|
-   PCL::SLOT-DEFINITION-BOUNDP-FUNCTION
-   PCL::SLOT-DEFINITION-WRITER-FUNCTION
-   PCL::SLOT-DEFINITION-READER-FUNCTION
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION CLASS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS)| SYSTEM::OBJECT
+   PCL::ARGUMENTS PCL::WRITER PCL::CACHE-NLINES PCL::*SLOTD-UNSUPPLIED*
+   COMMON-LISP::MACRO-FUNCTION PCL::DO-STANDARD-DEFSETF
+   PCL::|ARG-INFO SLOT9| PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION
    PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
-   PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION PCL::NEW-P
-   PCL::METHOD-KEY 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 CSTRUCT::C-CONS-CAR PCL::HIT
+   PCL::SLOT-DEFINITION-READER-FUNCTION
+   PCL::SLOT-DEFINITION-WRITER-FUNCTION
+   PCL::SLOT-DEFINITION-BOUNDP-FUNCTION PCL::NEW-P PCL::METHOD-KEY
+   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 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::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION PCL::WHY
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
+   PCL::WHY PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
    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-NAMES PCL::SLOT-NAME
+   PCL::RECOMP-REASONS PCL::SLOT-NAME PCL::SLOT-NAMES
    PCL::FIND-SUPERCLASS-CHAIN PCL::CHASE PCL::FAST-METHOD-CALL-FUNCTION
    PCL::|ARG-INFO SLOT8| CSTRUCT::C-SET-HASHTABLE-NENT PCL::PV-OFFSET
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
@@ -3316,9 +3314,9 @@
    COMMON-LISP::*LOAD-PRINT* PCL::DFUN COMMON-LISP::CONCATENATE
    COMMON-LISP::&ALLOW-OTHER-KEYS COMMON-LISP::TREE-EQUAL
    COMMON-LISP::DEFINE-SYMBOL-MACRO
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LINE-SIZE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SIZE)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SIZE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LINE-SIZE)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT MASK)| PCL::CHECK-MEMBER
    PCL::COPY-INITIAL-DISPATCH PCL::MAKE-METHOD-FUNCTION
    PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-ENTRY-FN
@@ -3337,19 +3335,19 @@
    PCL::DNET-METHODS-P PCL::EARLY-P COMMON-LISP::CIS PCL::ACCESSOR
    PCL::MAP-PV-TABLE-REFERENCES-OF PCL::SLOT-DEFINITION-SIMPLE-TYPEP-FN
    PCL::|ARG-INFO SLOT6|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)| 
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PREDICATE-NAME)|
-   PCL::|(FAST-READER-METHOD CLASS PREDICATE-NAME)|
-   PCL::|(FAST-READER-METHOD CLASS NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-NAME)|
-   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DFUN-STATE)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT NAME)|
    PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT NAME)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION NAME)|
+   PCL::|(FAST-READER-METHOD CLASS NAME)|
+   PCL::|(FAST-READER-METHOD CLASS PREDICATE-NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PREDICATE-NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAME)|
+   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
    CSTRUCT::C-ARRAY-ELTTYPE PCL::UNTRACE-METHOD PCL::BEEN-HERE
    PCL::MAIN-EFFECTIVE-METHOD COMMON-LISP::CHAR= PCL::AUGMENT-TYPE
@@ -3363,7 +3361,7 @@
    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-ARGUMENT-POSITIONS PCL::SPECIALIZED-POSITIONS
+   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)|
@@ -3406,11 +3404,11 @@
    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-INITARGS-FORM-INTERNAL
-   PCL::MAKE-METHOD-LAMBDA-INTERNAL PCL::MAKE-METHOD-FUNCTION-INTERNAL
-   COMMON-LISP::LONG-FLOAT COMMON-LISP::SIMPLE-VECTOR-P
-   CSTRUCT::C-STREAM-MODE PCL::DFUN-INFO-CACHE
-   COMMON-LISP::ECHO-STREAM-INPUT-STREAM
+   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 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
@@ -3421,11 +3419,11 @@
    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
-   CSTRUCT::C-PACKAGE-EXTERNAL_SIZE PCL::OFUNCTION PCL::TFUNCTION
-   PCL::CFUNCTION PCL::.FUNCTION. PCL::DEFAULT-INITARGS-1
+   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 METHODS)| PCL::|(WRITER OPTIONS)| COMMON-LISP::BOOLEAN
+   PCL::|(WRITER OPTIONS)| PCL::|(WRITER METHODS)| COMMON-LISP::BOOLEAN
    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
@@ -3433,49 +3431,50 @@
    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::INSTANCE-SLOTS PCL::OBJECTSP PCL::DFUN-INFO PCL::DFUN-INFO-
    PCL::FILENAMES PCL::SETF-CASE
    COMMON-LISP::SIMPLE-CONDITION-FORMAT-ARGUMENTS
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::RAW)| PCL::KEY-NAMES
    PCL::MAKE-DEFMETHOD-FORM-INTERNAL PCL::ONE-INDEX-LIMIT-FN
-   PCL::|(WRITER DIRECT-SUBCLASSES)|
-   PCL::|(WRITER DIRECT-SUPERCLASSES)| COMMON-LISP::MAKE-ARRAY
+   PCL::|(WRITER DIRECT-SUPERCLASSES)|
+   PCL::|(WRITER DIRECT-SUBCLASSES)| COMMON-LISP::MAKE-ARRAY
    PCL::FAST-FUNCTION PCL::IGNORE3 PCL::|(WRITER BOUNDP-FUNCTION)|
    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 CSTRUCT::C-SET-T-MELTMODE
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::FROZEN)|
-   PCL::WALK-FUNCTION COMMON-LISP::SUBLIS PCL::STR-METHOD
-   PCL::STD-METHOD PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VECTOR)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)| 
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
+   PCL::WALK-FUNCTION COMMON-LISP::SUBLIS PCL::STD-METHOD
+   PCL::STR-METHOD
    PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VECTOR)|
    PCL::GET-GENERIC-FUNCTION-INFO COMMON-LISP::DELETE-DUPLICATES
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::MACROS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CALL-METHOD-ARGS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITARGS)|
    PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITARGS)|
-   PCL::|(WRITER DIRECT-SLOTS)| PCL::|(WRITER DIRECT-METHODS)|
-   PCL::NREQUIREDS PCL::NREQUIRED CSTRUCT::C-SET-HASHTABLE-RHTHRESH
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITARGS)|
+   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 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
    COMMON-LISP::REMOVE-IF PCL::LINE-2 PCL::PARAMETER-ENTRY
    COMMON-LISP::WHEN
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::ARG-TYPES)|
-   PCL::|(WRITER INTERNAL-WRITER-FUNCTION)|
+   PCL::|(WRITER METHOD-COMBINATION)|
    PCL::|(WRITER INTERNAL-READER-FUNCTION)|
-   PCL::|(WRITER METHOD-COMBINATION)| PCL::FUN-TO-FUNCALLABLE-INSTANCE
-   PCL::NEW-METHOD PCL::GET-METHOD PCL::|COMPILER::FN SLOT2|
-   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::RAND-BASE
-   COMMON-LISP::ADJUSTABLE-ARRAY-P PCL::CLASSES-LIST
+   PCL::|(WRITER INTERNAL-WRITER-FUNCTION)|
+   PCL::FUN-TO-FUNCALLABLE-INSTANCE PCL::GET-METHOD PCL::NEW-METHOD
+   PCL::|COMPILER::FN SLOT2| PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS
+   PCL::RAND-BASE COMMON-LISP::ADJUSTABLE-ARRAY-P PCL::CLASSES-LIST
    PCL::RETURN-VALUE-P PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)|
    PCL::.FAST-CALL-METHOD-LIST. PCL::METHOD-CALL-CALL-METHOD-ARGS
    PCL::|(WRITER METHOD-CLASS)| PCL::OPERATION-TRANSFORMATIONS
    PCL::IGNORE2 PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NLINES)|
-   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| PCL::|__si::MAKE-ARG-INFO|
-   PCL::|__si::MAKE-DFUN-INFO| PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|
+   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::/// 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)|
@@ -3488,12 +3487,12 @@
    COMMON-LISP::HASH-TABLE-REHASH-SIZE PCL::|(WRITER FAST-FUNCTION)|
    PCL::MAKE-UNORDERED-METHODS-EMF PCL::WITH-LOCAL-CACHE-FUNCTIONS
    PCL::|COMPILER::FN SLOT1| PCL::METHOD-ALIST-P
-   COMMON-LISP::NAMESTRING PCL::PROTO-GF PCL::FIN
+   COMMON-LISP::NAMESTRING PCL::FIN PCL::PROTO-GF
    PCL::DEFINE-GF-PREDICATE CSTRUCT::C-FLOAT-DOUBLE-==
    PCL::|PCL::PLIST-MIXIN class predicate| PCL::AROUND
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
-   PCL::|(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
+   PCL::|(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
    PCL::DO-WRITER-DEFINITION PCL::LEGAL-METHOD-FUNCTION-P
    PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::SO-FAR ITERATE::COLLECTING
    PCL::MAKE-READER-METHOD-FUNCTION PCL::IGNORE1 COMMON-LISP::VECTORP
--- gcl27-2.7.0.orig/pcl/sys-proclaim.lisp
+++ gcl27-2.7.0/pcl/sys-proclaim.lisp
@@ -1,12 +1,68 @@
 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION
+    ((T) (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))
+     (NULL)))
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER PCL::EMIT-READER/WRITER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 0 268435455)) PCL::EARLY-CLASS-SIZE
+   PCL::ARG-INFO-NKEYS PCL::ARG-INFO-NUMBER-REQUIRED)) 
+(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))|)) 
+(PROCLAIM '(FTYPE (FUNCTION ((T) (T) &REST T) NIL) PCL::CPL-ERROR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
+   PCL::GENERIC-FUNCTION-NREQ)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::METHOD-CALL))
+   PCL::MAKE-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (MEMBER #())) PCL::COMPUTE-CALLS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::PARSE-QUALIFIER-PATTERN)) 
 (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-2)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
     (OR
      (SIMPLE-ARRAY FIXNUM 1) (SIMPLE-ARRAY T 1)
      (SIMPLE-ARRAY SYSTEM:SIGNED-INT 1)
@@ -22,111 +78,351 @@
      (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)) 
+   PCL::EARLY-COLLECT-DEFAULT-INITARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
-   PCL::SYMBOL-LESSP)) 
+   (FUNCTION ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
+   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T 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))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::NO-METHODS))
+   PCL::NO-METHODS-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
 (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)) 
+    (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) (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))
     (VALUES
-     &OPTIONAL (T) (T)
      (OR
       (OR
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::CACHING))
-      (MEMBER NIL))))
-   PCL::MAKE-FINAL-CACHING-DFUN)) 
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (OR (NULL) (SYSTEM:PROPER-CONS (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))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::EARLY-COLLECT-INHERITANCE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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::CHECKING)) (STRUCTURE PCL::CHECKING))
+   PCL::COPY-CHECKING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE))
+   PCL::|STRUCTURE-OBJECT class constructor|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
+   PCL::COPY-STD-INSTANCE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (VALUES (T) (T)))
+   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
+(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)) 
+(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)) 
 (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)) 
+     (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 ((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)) (OR (INTEGER 0 12) (MEMBER NIL)))
+   PCL::WRAPPER-FIELD)) 
 (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) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::FILL-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (T)) PCL::ONE-INDEX-CACHE
+   PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::TWO-CLASS-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (VALUES (T) (T) (T)))
+   PCL::PARSE-METHOD-OR-SPEC)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (NULL))
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION 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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::INITIAL-DISPATCH)) (T))
+   PCL::INITIAL-DISPATCH-CACHE)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T)) (T))
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
+(PROCLAIM
+ '(FTYPE
+   (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)
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (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-METHODS)) 
+    ((T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|)) 
+   (FUNCTION
+    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
+    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::COMPUTE-STD-CPL-PHASE-3)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
+    ((T) (T) (T))
     (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::REAL-MAKE-METHOD-LAMBDA)) 
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
+   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
+   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
+(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)) 
+(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
+    ((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::CACHE)) (T)) PCL::CACHE-OWNER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
+   PCL::COMPUTE-LINE-SIZE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (T)) PCL::CHECKING-CACHE
+   PCL::CHECKING-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
+(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
+   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::GENERATE-FAST-CLASS-SLOT-ACCESS-P 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-LAMBDA-LIST-P
+   PCL::LEGAL-QUALIFIERS-P PCL::INVOKE-EMF
+   PCL::MAKE-BOUNDP-METHOD-FUNCTION PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS
+   DOCUMENTATION PCL::MAKE-INSTANCE-FUNCTION-TRAP
+   PCL::REMOVE-WRITER-METHOD PCL::UPDATE-GF-DFUN PCL::INITIAL-DFUN
+   PCL::REMOVE-READER-METHOD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) &REST T) (VALUES (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
    PCL::GET-METHOD-FUNCTION)) 
 (PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::INITIAL)) (T)) PCL::INITIAL-CACHE)) 
+ '(FTYPE
+   (FUNCTION
+    ((INTEGER 0 9223372036854775807) (T) &REST T)
+    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::FIND-FREE-CACHE-LINE)) 
+(PROCLAIM
+ '(FTYPE
+   (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
@@ -137,113 +433,306 @@
    PCL::OPTIMIZE-GF-CALL)) 
 (PROCLAIM
  '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::COPY-TWO-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
+(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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
+   PCL::|__si::MAKE-ONE-INDEX|)) 
+(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::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 ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
+   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
+   PCL::CACHE-SIZE)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::ARG-INFO)) PCL::MAKE-ARG-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL))
+   PCL::|__si::MAKE-INITIAL|)) 
+(PROCLAIM
+ '(FTYPE
    (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)) 
+    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::COPY-CONSTANT-VALUE)) 
 (PROCLAIM
- '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::INITIAL-DISPATCH))
-    (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::COPY-INITIAL-DISPATCH)) 
+    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
+(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)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (INTEGER 0 9223372036854775807))
-    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::FILL-CACHE-FROM-CACHE-P)) 
+    ((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 (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
+   (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::SLOT-VALUE-OR-DEFAULT
+   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) (T) (T) (T))
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
-   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN)) 
+    ((T))
+    (VALUES
+     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
+     (T)))
+   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
+   (FUNCTION
+    ((T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (NULL))
+   PCL::MAP-ALL-ORDERS)) 
 (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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (SYSTEM:PROPER-CONS (T) (T)) (T)))
-   PCL::SPLIT-DECLARATIONS-MOVING-IGNORES)) 
+     (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 ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
+   (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)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL PCL::ENSURE-CLASS-VALUES)) 
+   (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))|)) 
+   (FUNCTION
+    ((T) (T))
+    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::FORM-LIST-TO-LISP)) 
 (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 ((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) (STRUCTURE PCL::INITIAL))
-   PCL::|__si::MAKE-INITIAL|)) 
+   (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)) (MEMBER :INSTANCE))
+   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::CPD-COUNT)) 
+    ((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)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::SAUT-NOT)) 
+   (FUNCTION ((T) (T) (T) (NULL) (T)) (T))
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
+   PCL::N-N-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
+   PCL::|__si::MAKE-PV-TABLE|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
-   PCL::GET-MAKE-INSTANCE-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 ((T)) (INTEGER 0 268435455)) PCL::EARLY-CLASS-SIZE
-   PCL::ARG-INFO-NKEYS PCL::ARG-INFO-NUMBER-REQUIRED)) 
+   (FUNCTION
+    ((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
-    ((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)) 
+    ((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) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::INITIALIZE-INFO)) 
+(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))|)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
 (PROCLAIM
  '(FTYPE
    (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) &REST T) (NULL)) ITERATE::MAYBE-WARN
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
     (VALUES
-     (INTEGER 0 268435455) (T)
+     (SYSTEM:PROPER-CONS (T) (T))
      (OR
       (OR
        (OR
@@ -266,273 +755,160 @@
         (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)) 
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
+   PCL::DESTRUCTURE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (T)))
-   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (T))
+   PCL::LOAD-DEFMETHOD-INTERNAL)) 
 (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)) 
+    ((T) (T) (T) (T) (T))
+    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
+   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) NIL) PCL::NO-SLOT PCL::CPL-INCONSISTENT-ERROR
-   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHE)) (T)) PCL::CACHE-OWNER)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (SIMPLE-ARRAY T (6)))
+   PCL::MAKE-FGEN)) 
 (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
+    ((STRUCTURE PCL::INITIAL-DISPATCH))
+    (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::COPY-INITIAL-DISPATCH)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
-   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
+   PCL::CACHE-LINE-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
-   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
+   (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)) (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) (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::FAST-INSTANCE-BOUNDP))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
+    ((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 NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
+   (FUNCTION
+    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
+   PCL::SYMBOL-OR-CONS-LESSP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (VALUES
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (OR (NULL) (SYSTEM:PROPER-CONS (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))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::EARLY-COLLECT-INHERITANCE)) 
+    ((T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   ITERATE::FUNCTION-LAMBDA-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-   PCL::MAKE-FAST-INSTANCE-BOUNDP)) 
+   (FUNCTION
+    ((T) (T))
+    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-AND)) 
 (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 DEFAULT-INITARGS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (T 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)) 
+ '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
+   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
+   PCL::CONSTANT-VALUE-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((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 NIL (STRUCTURE PCL::ARG-INFO)) PCL::MAKE-ARG-INFO)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::GET-ACCESSOR-METHOD-FUNCTION)) 
 (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 ((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) (T))
-    (OR
+    ((T))
+    (VALUES
+     &OPTIONAL
      (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-APPLICABLE-METHODS)) 
+      (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
-    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
-    (INTEGER 0 9223372036854775807))
-   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::CACHE-VALUEP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM)))
+    ((T) (T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
+     (T))
     (VALUES &REST T))
-   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|)) 
-(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)) 
+   PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
-   ITERATE::SEQUENCE-ACCESSOR)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
+   PCL::CACHE-MISS-VALUES-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     &REST T)
+    ((T) (T) (T) (T) &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)) 
+   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)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T) (T) &REST T) (T)) PCL::REAL-GET-METHOD)) 
+   (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
-    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
-     (T))
-    (VALUES &REST T))
-   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|)) 
+   (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) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
-   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+   (FUNCTION
+    ((T))
+    (OR
+     (SIMPLE-ARRAY CHARACTER (*))
+     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
+   PCL::SYMBOL-PKG-NAME)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
+    ((T) (T))
     (VALUES
      (T)
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))))
-   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))))
+   PCL::ENSURE-CLASS-VALUES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::MAKE-INITIALIZE-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T)) (VALUES &REST T)) SYSTEM::CLASSP
@@ -550,17 +926,17 @@
    PCL::WRAPPER-FETCHER PCL::SLOT-WRITER-SYMBOL PCL::|PV-TABLE SLOT1|
    PCL::STANDARD-WRITER-METHOD-P
    PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
    PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER| PCL::|PV-TABLE SLOT0|
+   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::RAW-INSTANCE-ALLOCATOR
    PCL::STANDARD-BOUNDP-METHOD-P
-   PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
-   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
    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::STANDARD-CLASS-P PCL::|SYSTEM:S-DATA SLOT7|
    PCL::|SYSTEM:S-DATA SLOT6| PCL::|SYSTEM:S-DATA SLOT5|
@@ -661,95 +1037,156 @@
    PCL::|FAST-INSTANCE-BOUNDP SLOT0|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
-   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION ((T)) (NOT (MEMBER NIL))) PCL::EARLY-CLASS-DEFINITION
+   PCL::GET-PV-CELL-FOR-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
-   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
+   (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) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-DLAP)) 
+    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 ((T) (T) (T) (STRUCTURE) (T)) (T))
-   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-CLASS))
+   PCL::|__si::MAKE-ONE-CLASS|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (VALUES
+     (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)))))
+   PCL::ADD-METHOD-DECLARATIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::|__si::MAKE-ARG-INFO|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (OR
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
+       (STRUCTURE PCL::CHECKING))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-CHECKING-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T))
+    (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) &REST T)
-    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
-   MAKE-LOAD-FORM-SAVING-SLOTS)) 
+    (VALUES
+     (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
 (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::INITIAL)) (STRUCTURE PCL::INITIAL))
+   PCL::COPY-INITIAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+   (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)) (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 (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::STRING-APPEND)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
-   PCL::CONSTANT-VALUE-CACHE)) 
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
-   PCL::MAKE-N-N-ACCESSOR-DFUN)) 
+    ((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 ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
+(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 ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
+   PCL::|__si::MAKE-DFUN-INFO|)) 
 (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)) 
+    ((STRUCTURE PCL::CACHE))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::CACHE-OVERFLOW)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
-   PCL::COPY-DISPATCH)) 
+   (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::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 (&REST T) (STRUCTURE PCL::TWO-CLASS))
-   PCL::|__si::MAKE-TWO-CLASS|)) 
+   (FUNCTION
+    ((T) (T) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
 (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)) 
+    ((T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-DLAP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T)) (NULL))
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD 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 ((T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
@@ -760,61 +1197,715 @@
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
-    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
-   PCL::MAKE-INSTANCE-FUNCTION-COMPLEX)) 
+    ((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 (&REST T) (STRUCTURE PCL::METHOD-CALL))
-   PCL::MAKE-METHOD-CALL)) 
+   (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) (T)) (MEMBER #())) PCL::COMPUTE-CALLS)) 
+ '(FTYPE
+   (FUNCTION
+    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::KEY-NAMES)) 
+(PROCLAIM '(FTYPE (FUNCTION (&REST T) (INTEGER 0 0)) PCL::ZERO)) 
+(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) &REST T) (VALUES (T) (T)))
+   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS
+   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
+   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
+   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
+   PCL::CACHE-NKEYS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::CACHES-TO-ALLOCATE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) &REST T)
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
-   PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
 (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 ((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 (&REST T) (STRUCTURE PCL::DISPATCH))
-   PCL::|__si::MAKE-DISPATCH|)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ACCESSOR-DFUN-INFO)) (T))
+   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::CACHE))
+    ((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)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (VALUES &REST T))
+   PCL::ORDER-SPECIALIZERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::MAKE-FAST-INSTANCE-BOUNDP)) 
+(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 DEFAULT-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (T 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)) 
+(PROCLAIM
+ '(FTYPE
+   (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) (T))
     (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-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
+       (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)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (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-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
+   PCL::CHECK-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::MAKE-FAST-METHOD-CALL)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
+   PCL::INTERNED-SYMBOL-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (STRUCTURE) (T)) NIL)
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
+(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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::TWO-CLASS))
+   PCL::|__si::MAKE-TWO-CLASS|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   ITERATE::PARSE-DECLARATIONS)) 
+(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 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 ((T) (T) (T) (T) &REST T) (T)) PCL::ADD-NAMED-METHOD
+   PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE)) 
+(PROCLAIM '(FTYPE (FUNCTION (&REST T) (SYSTEM:TRUE)) PCL::TRUE)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::PV-TABLE))
+   PCL::MAKE-PV-TABLE-INTERNAL)) 
+(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::TWO-CLASS SLOT4| SETF::|PCL::SYSTEM:S-DATA SLOT2|
+   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 SLOT-VALUE
+   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::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::MEC-ALL-CLASSES 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::FIND-STANDARD-II-METHOD PCL::SLOT-BOUNDP-NORMAL
+   PCL::SET-STANDARD-SVUC-METHOD PCL::PROCLAIM-DEFGENERIC
+   PCL::SET-WRAPPER PCL::ADD-FORMS PCL::SLOT-VALUE-NORMAL
+   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) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
+   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
+   PCL::CACHE-VECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (STRUCTURE PCL::ARG-INFO)))
+   PCL::TYPES-FROM-ARGUMENTS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::MAKE-CPD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
+   PCL::COPY-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T) (T) &REST T) (T)) PCL::REAL-GET-METHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
+   PCL::|__si::MAKE-CHECKING|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   PCL::SPLIT-DECLARATIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
+   PCL::COPY-CACHING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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::CACHE-OVERFLOW)) 
+   PCL::GENERATING-LISP)) 
 (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)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::RESET-INITIALIZE-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::INITIALIZE-INFO)) 
+   (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
+     &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 ((T) (T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
+   PCL::ACCESSOR-VALUES)) 
+(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)) 
+(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 (&REST T) (STRUCTURE PCL::DISPATCH))
+   PCL::|__si::MAKE-DISPATCH|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T)) (T))
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
+   PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
+   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-EMF-CACHE
+   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) (INTEGER 0 9223372036854775807))
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::FILL-CACHE-FROM-CACHE-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (INTEGER 0 9223372036854775807))
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    (&REST T)
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::MAKE-PROGN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
      (OR
-      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
-     (T)
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (INTEGER -9223372036854775807 9223372036854775807)))
+   PCL::COMPUTE-STD-CPL-PHASE-1)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::COPY-ACCESSOR-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
+   PCL::FALSE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::CPD-COUNT)) 
+(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*)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
+   PCL::COPY-N-N)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::METHOD-CALL)) (T))
+   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::PV-TABLE-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES
      (OR
       (OR
        (OR
@@ -837,136 +1928,129 @@
         (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))|)) 
+      (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) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
+   PCL::|__si::MAKE-CACHING|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (T)) SYSTEM::CLASS-PRECEDENCE-LIST
-   SYSTEM::CLASS-DIRECT-SUBCLASSES SYSTEM:%STRUCTURE-NAME
-   WALKER::ENV-DECLARATIONS WALKER::ENV-WALK-FORM WALKER::ENV-LOCK
-   WALKER::GET-WALKER-TEMPLATE WALKER::ENV-WALK-FUNCTION
-   WALKER::ENV-LEXICAL-VARIABLES PCL:CLASS-PRECEDENCE-LIST
-   PCL:SLOT-DEFINITION-WRITERS CLASS-OF PCL:INTERN-EQL-SPECIALIZER
-   PCL:METHOD-GENERIC-FUNCTION PCL:GENERIC-FUNCTION-DECLARATIONS
-   PCL:GENERIC-FUNCTION-METHODS PCL:SLOT-DEFINITION-TYPE
-   PCL:GENERIC-FUNCTION-METHOD-COMBINATION PCL:SLOT-DEFINITION-INITARGS
-   PCL:GENERIC-FUNCTION-METHOD-CLASS PCL:SLOT-DEFINITION-INITFUNCTION
-   PCL:SLOT-DEFINITION-LOCATION PCL:ACCESSOR-METHOD-SLOT-DEFINITION
-   PCL:GENERIC-FUNCTION-NAME PCL:SLOT-DEFINITION-NAME
-   PCL:SLOT-DEFINITION-INITFORM CLASS-NAME PCL:SLOT-DEFINITION-READERS
-   PCL:CLASS-DIRECT-SUBCLASSES PCL:CLASS-DIRECT-SUPERCLASSES
-   PCL::*NORMALIZE-TYPE PCL::SHORT-COMBINATION-OPERATOR
-   PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::EARLY-CLASS-SLOTDS
-   PCL::USE-CACHING-DFUN-P PCL::BUILT-IN-WRAPPER-OF
-   PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME
-   PCL::METHOD-COMBINATION-DOCUMENTATION PCL::FGEN-GENERATOR-LAMBDA
-   PCL::EARLY-CLASS-PRECEDENCE-LIST-SYMBOL
-   PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST PCL::METHOD-FUNCTION-METHOD
-   PCL::FORCE-CACHE-FLUSHES PCL::EARLY-CLASS-NAME-OF
-   PCL::METHOD-COMBINATION-TYPE PCL::UNDEFMETHOD-1
-   PCL::CHECK-WRAPPER-VALIDITY PCL::GMAKUNBOUND
-   PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 
-   PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST PCL::STRUCTURE-WRAPPER
-   PCL::STRUCTURE-SLOTD-READER-FUNCTION
-   PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::STORE-FGEN
-   PCL::STRUCTURE-SLOTD-INIT-FORM PCL::DEFINITION-SOURCE
-   PCL::STRUCTURE-SLOTD-TYPE PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME
-   PCL::STRUCTURE-SVUC-METHOD PCL::CLASS-WRAPPER
-   PCL::STRUCTURE-SLOTD-NAME PCL::ARG-INFO-APPLYP
-   PCL::LONG-METHOD-COMBINATION-ARGUMENTS-LAMBDA-LIST
-   PCL::ECD-SUPERCLASS-NAMES PCL::LONG-METHOD-COMBINATION-FUNCTION
-   PCL::FIND-STRUCTURE-CLASS PCL::STRUCTURE-TYPE PCL::CLASS-FROM-TYPE
-   PCL::EQL-SPECIALIZER-OBJECT PCL::SLOT-DEFINITION-CLASS
-   PCL::CLASS-NAME-OF PCL::GF-DFUN-INFO
-   PCL::SLOT-DEFINITION-BOUNDP-FUNCTION
-   PCL::SLOT-DEFINITION-WRITER-FUNCTION
-   PCL::SLOT-DEFINITION-READER-FUNCTION
-   PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
-   PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION PCL::EARLY-GF-NAME
-   PCL::GF-PRETTY-ARGLIST PCL::CLASS-DEFSTRUCT-FORM PCL::CLASS-EQ-TYPE
-   PCL::WRAPPER-OF PCL::NET-TEST-CONVERTER PCL::EARLY-METHOD-QUALIFIERS
-   PCL::GF-DFUN-CACHE PCL::GF-ARG-INFO
-   PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION
-   PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::EARLY-CLASS-SLOTS
-   PCL::ECD-METACLASS PCL::CLASS-CAN-PRECEDE-LIST PCL::MK-EARLY-CPL
-   PCL::METHOD-COMBINATION-OPTIONS PCL::STANDARD-SVUC-METHOD
-   PCL::TYPE-CLASS PCL::SETFBOUNDP PCL::EARLY-CLASS-NAME
-   PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P
-   PCL::METHOD-FUNCTION-PV-TABLE PCL::FIND-WRAPPER
-   PCL::UPDATE-ALL-C-A-M-GF-INFO WALKER:VARIABLE-GLOBALLY-SPECIAL-P
-   PCL::CLASS-INITIALIZE-INFO PCL::DEFAULT-TEST-CONVERTER
-   PCL::CANONICAL-SLOT-NAME PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS
-   PCL::GET-BUILT-IN-CLASS-SYMBOL PCL::GET-BUILT-IN-WRAPPER-SYMBOL
-   PCL::FGEN-SYSTEM PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL
-   PCL::DEFAULT-STRUCTURE-TYPE PCL::EARLY-SLOT-DEFINITION-LOCATION
-   PCL::WRAPPER-FOR-STRUCTURE PCL::GENERIC-CLOBBERS-FUNCTION
-   PCL::GENERIC-FUNCTION-INITIAL-METHODS
-   PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::ECD-CLASS-NAME
-   PCL::CLASS-EQ-SPECIALIZER PCL::EARLY-SLOT-DEFINITION-NAME
-   PCL::FGEN-TEST PCL::ECD-OTHER-INITARGS PCL::SHOW-DFUN-COSTS
-   PCL::MAKE-INITFUNCTION
-   PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P
-   PCL::CONVERT-TO-SYSTEM-TYPE PCL::SPECIALIZER-OBJECT
-   PCL::ECD-CANONICAL-SLOTS PCL::TYPE-FROM-SPECIALIZER PCL::LOOKUP-FGEN
-   PCL::FGEN-GENSYMS PCL::METHOD-FAST-FUNCTION
-   PCL::CLASS-DEFSTRUCT-CONSTRUCTOR PCL::GF-DFUN-STATE
-   PCL::SPECIALIZER-TYPE PCL::FGEN-GENERATOR
-   PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL PCL::OBJECT-PLIST
-   PCL::EARLY-METHOD-LAMBDA-LIST PCL::EARLY-METHOD-CLASS
-   PCL::%CCLOSURE-ENV PCL::MAKE-INITIAL-DFUN
-   PCL::SHORT-COMBINATION-IDENTITY-WITH-ONE-ARGUMENT
-   PCL::METHOD-FUNCTION-PLIST PCL::ECD-SOURCE)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES))
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-   PCL::COPY-ACCESSOR-DFUN-INFO)) 
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (OR
+       (STRUCTURE PCL::N-N) (STRUCTURE PCL::CACHING)
+       (STRUCTURE PCL::CONSTANT-VALUE) (STRUCTURE PCL::DISPATCH)
+       (STRUCTURE PCL::ONE-INDEX) (STRUCTURE PCL::ONE-CLASS)
+       (STRUCTURE PCL::DEFAULT-METHOD-ONLY) (STRUCTURE PCL::CHECKING)
+       (STRUCTURE PCL::NO-METHODS))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-DFUN-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EXPAND-DEFMETHOD)) 
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::ONE-CLASS-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::FUN-TO-FUNCALLABLE-INSTANCE)) 
+   (FUNCTION ((T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHING)) (T)) PCL::CACHING-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 7)) PCL::CACHE-FIELD)) 
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
+   PCL::CHECKING-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
-   PCL::COPY-ARG-INFO)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::CONSTANT-VALUE-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (NOT (MEMBER NIL))) PCL::EARLY-CLASS-DEFINITION
-   PCL::GET-PV-CELL-FOR-CLASS)) 
-(PROCLAIM '(FTYPE (FUNCTION (&REST T) (INTEGER 0 0)) PCL::ZERO)) 
+   (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 ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
-   PCL::COPY-CACHING)) 
+   (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) (T) (INTEGER 0 268435455) (T)) (T))
+   PCL::UPDATE-SLOTS-IN-PV)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST 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-OR-N-INDEX-READER/WRITER PCL::EMIT-READER/WRITER)) 
+      (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 ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
+   (FUNCTION
+    ((T)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
+   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
+(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 :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-WRITER-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 (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T 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) (T) (T) (STRUCTURE) (T)) (T))
+   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION (&REST T) (VALUES &REST T))
@@ -1300,26 +2384,26 @@
    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::PATHNAME class predicate|
-   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
-   PCL::|COMMON-LISP::READTABLE class predicate|
-   PCL::|COMMON-LISP::PACKAGE class predicate|
-   PCL::|COMMON-LISP::HASH-TABLE class predicate|
-   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
-   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
-   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
-   PCL::|COMMON-LISP::STRING-STREAM class predicate|
-   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
-   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
-   PCL::|COMMON-LISP::FILE-STREAM class predicate|
-   PCL::|COMMON-LISP::STREAM class predicate|
-   PCL::|COMMON-LISP::ARRAY class predicate|
-   PCL::|COMMON-LISP::VECTOR class predicate|
-   PCL::|COMMON-LISP::STRING class predicate|
-   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
-   PCL::|COMMON-LISP::CHARACTER class predicate|
-   PCL::|COMMON-LISP::SYMBOL 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::NULL class predicate|
    PCL::|COMMON-LISP::CONS class predicate|
    PCL::|COMMON-LISP::LIST class predicate|
@@ -1379,144 +2463,193 @@
    PCL::|PCL::PV-TABLE class predicate|)) 
 (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::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 ((T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::LOAD-DEFMETHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
+   PCL::COPY-ARG-INFO)) 
+(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)) 
+    ((OR
+      (OR
+       (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 ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
-   PCL::COPY-ONE-INDEX)) 
+   (FUNCTION
+    ((STRUCTURE PCL::INITIALIZE-INFO))
+    (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::COPY-INITIALIZE-INFO)) 
 (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
+    ((STRUCTURE PCL::FAST-METHOD-CALL))
+    (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::COPY-FAST-METHOD-CALL)) 
 (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::SLOT-VALUE-OR-DEFAULT
-   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
+    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
+   (FUNCTION
+    ((T) (T))
+    (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) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
-   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
+   (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)) (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 ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::EXPAND-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
+    ((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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL)))
     (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
+     (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
      (OR
       (OR
        (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::ADD-METHOD-DECLARATIONS)) 
+      (NULL))))
+   PCL::PARSE-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (VALUES &REST T))
-   PCL::MAKE-A-METHOD PCL::REAL-MAKE-A-METHOD)) 
+   (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))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
-   PCL::|__si::MAKE-DFUN-INFO|)) 
+   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
+   PCL::|__si::MAKE-STD-INSTANCE|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
-   PCL::GENERIC-FUNCTION-NREQ)) 
+   (FUNCTION ((T) (T)) NIL) PCL::NO-SLOT PCL::CPL-INCONSISTENT-ERROR
+   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
-   PCL::MAKE-FAST-METHOD-CALL)) 
+   (FUNCTION
+    ((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 NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
+   PCL::|__si::MAKE-NO-METHODS|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER :INSTANCE))
-   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::PV-TABLE-PV-SIZE)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::INITIAL)) (T)) PCL::INITIAL-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (SIMPLE-ARRAY T (6)))
-   PCL::MAKE-FGEN)) 
+   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   ITERATE::FUNCTION-LAMBDA-P)) 
+    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
+   PCL::POWER-OF-TWO-CEILING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
+   PCL::COPY-CACHE-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
-     (T))
-    (VALUES &REST T))
-   PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|)) 
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    NIL
-    (VALUES
-     &OPTIONAL
+    ((STRUCTURE PCL::FAST-METHOD-CALL))
+    (OR
      (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)) 
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::FAST-METHOD-CALL-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
-   PCL::STRING-APPEND)) 
+   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
+   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
+   PCL::%STD-INSTANCE-WRAPPER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
-   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::COPY-ONE-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
-   PCL::COPY-PV-TABLE)) 
+   (FUNCTION ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
+   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -1524,133 +2657,71 @@
       (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))
-     (T))
-    (NULL))
-   PCL::%CHECK-CNM-ARGS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
-   PCL::CACHE-NKEYS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((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)) 
+   PCL::PARSE-SPECIALIZED-LAMBDA-LIST)) 
 (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)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
+   PCL::NEXT-WRAPPER-FIELD)) 
 (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) &REST T) (NOT (MEMBER NIL)))
+   PCL::PV-TABLE-LOOKUP-PV-ARGS)) 
 (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::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)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-NOT)) 
 (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))|)) 
+    ((T) (T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (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::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|)) 
+     (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::REAL-MAKE-METHOD-LAMBDA)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
+    ((T) (T) (T) (T) (T) (T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MEMF-CODE-CONVERTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((INTEGER 0 9223372036854775807) (T) (T))
     (VALUES
-     &OPTIONAL (T) (T)
+     (INTEGER 0 9223372036854775807) (INTEGER 0 9223372036854775807)
+     (INTEGER 1 4611686018427387904) (INTEGER 0 9223372036854775807)))
+   PCL::COMPUTE-CACHE-PARAMETERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::METHOD-CALL))
+    (OR
      (OR
-      (OR
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::CHECKING))
-      (MEMBER NIL))))
-   PCL::MAKE-FINAL-CHECKING-DFUN)) 
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::METHOD-CALL-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T))
     (VALUES
+     (INTEGER 0 268435455) (T)
      (OR
       (OR
        (OR
@@ -1674,134 +2745,140 @@
         (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)) 
+     (INTEGER 0 268435455) (STRUCTURE PCL::ARG-INFO)))
+   PCL::GET-GENERIC-FUNCTION-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::|__si::MAKE-CONSTANT-VALUE|)) 
+   (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 ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
-   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
+   (FUNCTION
+    ((STRUCTURE PCL::CACHE))
+    (OR
+     (OR
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::CACHE-LIMIT-FN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL:SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
+   (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) (T) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
-   PCL::FILL-CACHE)) 
+   (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
+    ((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 ((T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T 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))|
-   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
-   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|)) 
+   (FUNCTION
+    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::CHECK-INITARGS-VALUES)) 
 (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)) 
+    ((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 (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
-   PCL::|__si::MAKE-PV-TABLE|)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (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)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
-   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
+    ((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) (STRUCTURE) (T)) (VALUES &REST T))
-   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
-   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (OR
-     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-     (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))
-     (MEMBER NIL)))
-   PCL::METHODS-CONVERTER)) 
+    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
 (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) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ARG-INFO))
-   PCL::|__si::MAKE-ARG-INFO|)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
-   PCL::ACCESSOR-VALUES)) 
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (OR
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING))
+      (MEMBER NIL))))
+   PCL::MAKE-CACHING-DFUN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T))
     (VALUES
-     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
      (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
-   PCL::*SUBTYPEP PCL::SAUT-CLASS-EQ PCL::SAUT-EQL)) 
+   PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::SAUT-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((INTEGER 0 9223372036854775807) (T) &REST T)
-    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::FIND-FREE-CACHE-LINE)) 
+   (FUNCTION ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
+   PCL::COPY-PV-TABLE)) 
 (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) &REST T) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::USE-DISPATCH-DFUN-P PCL::USE-CONSTANT-VALUE-DFUN-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
-(PROCLAIM
- '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::CONSTANT-VALUE-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
-   ITERATE::PARSE-DECLARATIONS)) 
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::MAKE-CPD)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::|__si::MAKE-CONSTANT-VALUE|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) (T) (T))
     (OR
      (OR
       (OR
@@ -1824,84 +2901,12 @@
        (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) (T))
-    (VALUES
-     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (SYSTEM:TRUE)))
-   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) &REST T)
-    (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   ITERATE::RENAME-LET-BINDINGS)) 
-(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::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 NIL (VALUES)) PCL::COUNT-ALL-DFUNS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::METHOD-CALL)) (T))
-   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::CACHE-VALUEP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::PV-TABLE))
-    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::PV-TABLE-CACHE)) 
-(PROCLAIM '(FTYPE (FUNCTION ((T) (T) &REST T) NIL) PCL::CPL-ERROR)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::CHECK-INITARGS-VALUES)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
-   PCL::SYMBOL-OR-CONS-LESSP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
+   PCL::SORT-APPLICABLE-METHODS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((STRUCTURE PCL::INITIALIZE-INFO)) (T))
-   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
    PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
    PCL::INITIALIZE-INFO-WRAPPER
    PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION
    PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION
@@ -1915,196 +2920,216 @@
    PCL::INITIALIZE-INFO-CACHED-VALID-P)) 
 (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 SLOT-VALUE
-   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::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::FIND-STANDARD-II-METHOD
-   PCL::SLOT-BOUNDP-NORMAL PCL::SET-STANDARD-SVUC-METHOD
-   PCL::PROCLAIM-DEFGENERIC PCL::SET-WRAPPER PCL::ADD-FORMS
-   PCL::SLOT-VALUE-NORMAL 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 ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::COPY-ONE-INDEX)) 
 (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)) 
+   (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
     ((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::GENERATING-LISP)) 
+      (OR
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-CACHING-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
+   (FUNCTION
+    ((T) (INTEGER 0 9223372036854775807) &REST T)
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE-FROM-CACHE)) 
 (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)) 
+    ((T) (T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (MEMBER NIL)
+      (OR
+       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::N-N)))))
+   PCL::MAKE-FINAL-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
-   PCL::|__si::MAKE-ONE-INDEX|)) 
+   (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) &REST T) (VALUES &REST T))
-   WALKER::WALK-DECLARATIONS FIND-METHOD PCL::GET-METHOD
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION)) 
+   (FUNCTION
+    ((T) (T) (T) &REST T)
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
+   PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((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)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) (T) (T))
     (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
-   PCL::SPLIT-DECLARATIONS)) 
+     (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)) (STRUCTURE PCL::N-N)) PCL::N-N-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
-   PCL::CACHE-MISS-VALUES-INTERNAL)) 
+   (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
-    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|)) 
 (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))|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
+   PCL::COPY-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
+   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (T)) SYSTEM::CLASS-PRECEDENCE-LIST
+   SYSTEM::CLASS-DIRECT-SUBCLASSES SYSTEM:%STRUCTURE-NAME
+   WALKER::ENV-DECLARATIONS WALKER::ENV-WALK-FORM WALKER::ENV-LOCK
+   WALKER::GET-WALKER-TEMPLATE WALKER::ENV-WALK-FUNCTION
+   WALKER::ENV-LEXICAL-VARIABLES PCL:CLASS-PRECEDENCE-LIST
+   PCL:SLOT-DEFINITION-WRITERS CLASS-OF PCL:INTERN-EQL-SPECIALIZER
+   PCL:METHOD-GENERIC-FUNCTION PCL:GENERIC-FUNCTION-DECLARATIONS
+   PCL:GENERIC-FUNCTION-METHODS PCL:SLOT-DEFINITION-TYPE
+   PCL:GENERIC-FUNCTION-METHOD-COMBINATION PCL:SLOT-DEFINITION-INITARGS
+   PCL:GENERIC-FUNCTION-METHOD-CLASS PCL:SLOT-DEFINITION-INITFUNCTION
+   PCL:SLOT-DEFINITION-LOCATION PCL:ACCESSOR-METHOD-SLOT-DEFINITION
+   PCL:GENERIC-FUNCTION-NAME PCL:SLOT-DEFINITION-NAME
+   PCL:SLOT-DEFINITION-INITFORM CLASS-NAME PCL:SLOT-DEFINITION-READERS
+   PCL:CLASS-DIRECT-SUBCLASSES PCL:CLASS-DIRECT-SUPERCLASSES
+   PCL::*NORMALIZE-TYPE PCL::SHORT-COMBINATION-OPERATOR
+   PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::EARLY-CLASS-SLOTDS
+   PCL::USE-CACHING-DFUN-P PCL::BUILT-IN-WRAPPER-OF
+   PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME
+   PCL::METHOD-COMBINATION-DOCUMENTATION PCL::FGEN-GENERATOR-LAMBDA
+   PCL::EARLY-CLASS-PRECEDENCE-LIST-SYMBOL
+   PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST PCL::METHOD-FUNCTION-METHOD
+   PCL::FORCE-CACHE-FLUSHES PCL::EARLY-CLASS-NAME-OF
+   PCL::METHOD-COMBINATION-TYPE PCL::UNDEFMETHOD-1
+   PCL::CHECK-WRAPPER-VALIDITY PCL::GMAKUNBOUND
+   PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 
+   PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST PCL::STRUCTURE-WRAPPER
+   PCL::STRUCTURE-SLOTD-READER-FUNCTION
+   PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::STORE-FGEN
+   PCL::STRUCTURE-SLOTD-INIT-FORM PCL::DEFINITION-SOURCE
+   PCL::STRUCTURE-SLOTD-TYPE PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME
+   PCL::STRUCTURE-SVUC-METHOD PCL::CLASS-WRAPPER
+   PCL::STRUCTURE-SLOTD-NAME PCL::ARG-INFO-APPLYP
+   PCL::LONG-METHOD-COMBINATION-ARGUMENTS-LAMBDA-LIST
+   PCL::ECD-SUPERCLASS-NAMES PCL::LONG-METHOD-COMBINATION-FUNCTION
+   PCL::FIND-STRUCTURE-CLASS PCL::STRUCTURE-TYPE PCL::CLASS-FROM-TYPE
+   PCL::EQL-SPECIALIZER-OBJECT PCL::SLOT-DEFINITION-CLASS
+   PCL::CLASS-NAME-OF PCL::GF-DFUN-INFO
+   PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION
+   PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
+   PCL::SLOT-DEFINITION-READER-FUNCTION
+   PCL::SLOT-DEFINITION-WRITER-FUNCTION
+   PCL::SLOT-DEFINITION-BOUNDP-FUNCTION PCL::EARLY-GF-NAME
+   PCL::GF-PRETTY-ARGLIST PCL::CLASS-DEFSTRUCT-FORM PCL::CLASS-EQ-TYPE
+   PCL::WRAPPER-OF PCL::NET-TEST-CONVERTER PCL::EARLY-METHOD-QUALIFIERS
+   PCL::GF-DFUN-CACHE PCL::GF-ARG-INFO
+   PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION
+   PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::EARLY-CLASS-SLOTS
+   PCL::ECD-METACLASS PCL::CLASS-CAN-PRECEDE-LIST PCL::MK-EARLY-CPL
+   PCL::METHOD-COMBINATION-OPTIONS PCL::STANDARD-SVUC-METHOD
+   PCL::TYPE-CLASS PCL::SETFBOUNDP PCL::EARLY-CLASS-NAME
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P
+   PCL::METHOD-FUNCTION-PV-TABLE PCL::FIND-WRAPPER
+   PCL::UPDATE-ALL-C-A-M-GF-INFO WALKER:VARIABLE-GLOBALLY-SPECIAL-P
+   PCL::CLASS-INITIALIZE-INFO PCL::DEFAULT-TEST-CONVERTER
+   PCL::CANONICAL-SLOT-NAME PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS
+   PCL::GET-BUILT-IN-CLASS-SYMBOL PCL::GET-BUILT-IN-WRAPPER-SYMBOL
+   PCL::FGEN-SYSTEM PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL
+   PCL::DEFAULT-STRUCTURE-TYPE PCL::EARLY-SLOT-DEFINITION-LOCATION
+   PCL::WRAPPER-FOR-STRUCTURE PCL::GENERIC-CLOBBERS-FUNCTION
+   PCL::GENERIC-FUNCTION-INITIAL-METHODS
+   PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::ECD-CLASS-NAME
+   PCL::CLASS-EQ-SPECIALIZER PCL::EARLY-SLOT-DEFINITION-NAME
+   PCL::FGEN-TEST PCL::ECD-OTHER-INITARGS PCL::SHOW-DFUN-COSTS
+   PCL::MAKE-INITFUNCTION
+   PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P 
+   PCL::CONVERT-TO-SYSTEM-TYPE PCL::SPECIALIZER-OBJECT
+   PCL::ECD-CANONICAL-SLOTS PCL::TYPE-FROM-SPECIALIZER PCL::LOOKUP-FGEN
+   PCL::FGEN-GENSYMS PCL::METHOD-FAST-FUNCTION
+   PCL::CLASS-DEFSTRUCT-CONSTRUCTOR PCL::GF-DFUN-STATE
+   PCL::SPECIALIZER-TYPE PCL::FGEN-GENERATOR
+   PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL PCL::OBJECT-PLIST
+   PCL::EARLY-METHOD-LAMBDA-LIST PCL::EARLY-METHOD-CLASS
+   PCL::%CCLOSURE-ENV PCL::MAKE-INITIAL-DFUN
+   PCL::SHORT-COMBINATION-IDENTITY-WITH-ONE-ARGUMENT
+   PCL::METHOD-FUNCTION-PLIST PCL::ECD-SOURCE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
+   ITERATE::SEQUENCE-ACCESSOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (OR
      (OR
       (OR
        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
@@ -2126,131 +3151,84 @@
        (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))|)) 
+   ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::FIND-SUPERCLASS-CHAIN
+   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (VALUES (T) (T)))
-   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
-   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS)) 
+   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
+   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) &REST T) (T))
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
+   (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) (T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::CHECK-INITARGS-2-PLIST PCL::CHECK-INITARGS-2-LIST
-   PCL::CHECK-INITARGS-1)) 
+ '(FTYPE (FUNCTION ((T) (T)) (VALUES (T) (T))) PCL::COMPUTE-CODE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
+    ((T) (T))
     (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (OR
-       (STRUCTURE PCL::N-N) (STRUCTURE PCL::CACHING)
-       (STRUCTURE PCL::CONSTANT-VALUE) (STRUCTURE PCL::DISPATCH)
-       (STRUCTURE PCL::ONE-INDEX) (STRUCTURE PCL::ONE-CLASS)
-       (STRUCTURE PCL::DEFAULT-METHOD-ONLY) (STRUCTURE PCL::CHECKING)
-       (STRUCTURE PCL::NO-METHODS))
-      (MEMBER NIL))))
-   PCL::MAKE-FINAL-DFUN-INTERNAL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::MAKE-INITIALIZE-INFO)) 
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (SYSTEM:PROPER-CONS (T) (T)) (T)))
+   PCL::SPLIT-DECLARATIONS-MOVING-IGNORES)) 
 (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)) 
+    ((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)) (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 ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
-   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
+    ((T) (T) (T))
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
+   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) 
 (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 ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
+   PCL::COPY-DISPATCH)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
-   PCL::COPY-DFUN-INFO)) 
+   (FUNCTION ((T) (T) (T) (T) (T) &REST T) (T))
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
 (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)) 
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
 (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)) 
+    ((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))
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
-   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) 
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::CHANGE-CLASS-INTERNAL)) 
 (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 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) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
+   (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 ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
-   PCL::COPY-TWO-CLASS)) 
+   (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)) (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 NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) (T)) (OR (SYSTEM:TRUE) (NULL))) SLOT-EXISTS-P
@@ -2260,59 +3238,8 @@
    PCL::LIST-EQ)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::COPY-CONSTANT-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 ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
-   PCL::CACHE-LINE-SIZE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
-   PCL::CHECK-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
-   PCL::CHECKING-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (OR
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::CHECKING))
-      (MEMBER NIL))))
-   PCL::MAKE-CHECKING-DFUN)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
-   PCL::|__si::MAKE-STD-INSTANCE|)) 
+   (FUNCTION ((T) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
+   PCL::SYMBOL-LESSP)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -2324,446 +3251,64 @@
    PCL::MAKE-SHARED-INITIALIZE-FORM-LIST)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T)) (T))
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (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 &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
-   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::GENERATE-FAST-CLASS-SLOT-ACCESS-P 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-LAMBDA-LIST-P
-   PCL::LEGAL-QUALIFIERS-P PCL::INVOKE-EMF
-   PCL::MAKE-BOUNDP-METHOD-FUNCTION PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS
-   DOCUMENTATION 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)) (NOT (MEMBER NIL))) PCL::PV-TABLE-LOOKUP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-FETCH-WRAPPER PCL::MAKE-EMF-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
-    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::COMPUTE-STD-CPL-PHASE-3)) 
-(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 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
-    ((T) (T) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY CHARACTER (*)))
-   PCL::CAPITALIZE-WORDS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T)
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (VALUES &REST T))
-   PCL::ORDER-SPECIALIZERS)) 
-(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)) 
-(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 ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
-   PCL::COPY-N-N)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::USE-DISPATCH-DFUN-P PCL::USE-CONSTANT-VALUE-DFUN-P)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::INITIALIZE-INFO))
-    (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::COPY-INITIALIZE-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::LIST-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)) 
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
-   PCL::BOOTSTRAP-SLOT-INDEX)) 
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::ONE-INDEX-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
-   PCL::INTERNED-SYMBOL-P)) 
+   (FUNCTION ((T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::FUN-TO-FUNCALLABLE-INSTANCE)) 
 (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)) 
+ '(FTYPE (FUNCTION ((T) (T)) (NOT (MEMBER NIL))) PCL::PV-TABLE-LOOKUP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-CLASS))
-   PCL::|__si::MAKE-ONE-CLASS|)) 
+   (FUNCTION ((T) (T)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T))
     (VALUES
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (INTEGER -9223372036854775807 9223372036854775807)))
-   PCL::COMPUTE-STD-CPL-PHASE-1)) 
-(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)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::COPY-DEFAULT-METHOD-ONLY)) 
-(PROCLAIM
- '(FTYPE
-   (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
-    ((STRUCTURE PCL::PV-TABLE))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::PV-TABLE-PV-SIZE)) 
-(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)) 
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (SYSTEM:TRUE)))
+   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
+    ((T) (T) &REST T)
     (VALUES
      &OPTIONAL (T) (T)
      (OR
       (OR
        (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::CACHING))
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
+       (STRUCTURE PCL::CHECKING))
       (MEMBER NIL))))
-   PCL::MAKE-CACHING-DFUN)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
-   PCL::EXPAND-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
-   PCL::COPY-STD-INSTANCE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (INTEGER 0 9223372036854775807))
-    (STRUCTURE PCL::CACHE))
-   PCL::GET-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::LIST-DFUN)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
-   PCL::N-N-ACCESSOR-TYPE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::INITIAL-DISPATCH)) (T))
-   PCL::INITIAL-DISPATCH-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
-   PCL::SET-ARG-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (INTEGER 0 268435455) (T)) (T))
-   PCL::UPDATE-SLOTS-IN-PV)) 
-(PROCLAIM
- '(FTYPE
-   (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) (T)) (OR (MEMBER "a string or NULL") (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
-   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   WALKER::WALK-BINDINGS-2)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION NIL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::CACHES-TO-ALLOCATE)) 
-(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) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
-   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (T)) PCL::PV-WRAPPERS-FROM-PV-ARGS
-   PCL::UNTRACE-METHOD PCL::INTERN-PV-TABLE PCL::LOAD-TRUENAME)) 
+   PCL::MAKE-CHECKING-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
-   PCL::ONE-CLASS-DFUN-INFO)) 
+   (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))
-    (VALUES
-     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
-     (T)))
-   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
+    ((STRUCTURE PCL::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
+   PCL::COPY-NO-METHODS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -2772,170 +3317,40 @@
    PCL::EMIT-CACHING PCL::EMIT-CHECKING)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
-   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
-   PCL::|__si::MAKE-CHECKING|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (INTEGER 0 9223372036854775807) &REST T)
-    (STRUCTURE PCL::CACHE))
-   PCL::GET-CACHE-FROM-CACHE)) 
-(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)) 
-(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 ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
-   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
-   PCL::CACHE-SIZE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
-   PCL::SET-ARG-INFO1)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE))
-   PCL::|STRUCTURE-OBJECT class constructor|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T))
-    (OR
-     (SIMPLE-ARRAY CHARACTER (*))
-     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
-   PCL::SYMBOL-PKG-NAME)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
-   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
-   PCL::TWO-CLASS-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
-   PCL::%STD-INSTANCE-WRAPPER)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
-   PCL::NEXT-WRAPPER-FIELD)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::KEY-NAMES)) 
-(PROCLAIM
- '(FTYPE
-   (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)) (STRUCTURE PCL::ONE-INDEX))
-   PCL::ONE-INDEX-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ACCESSOR-DFUN-INFO)) (T))
-   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE)) 
-(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
+      (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 METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|)) 
-(PROCLAIM
- '(FTYPE
-   (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)) (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) (T) (T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::GET-ACCESSOR-METHOD-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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
-   PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
-   PCL::ACCESSOR-VALUES1 PCL::ACCESSOR-VALUES-INTERNAL)) 
+   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
 (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)) 
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -2943,122 +3358,43 @@
    PCL::ALLOCATE-CACHE-VECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
-   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (MEMBER NIL)
-      (OR
-       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::N-N)))))
-   PCL::MAKE-FINAL-ACCESSOR-DFUN)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (NOT (MEMBER NIL)))
-   PCL::PV-TABLE-LOOKUP-PV-ARGS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
-   PCL::|__si::MAKE-NO-METHODS|)) 
+    ((T) (T) (T) (T))
+    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
 (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
-    ((STRUCTURE PCL::FAST-METHOD-CALL))
-    (STRUCTURE PCL::FAST-METHOD-CALL))
-   PCL::COPY-FAST-METHOD-CALL)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (STRUCTURE PCL::N-N)) PCL::N-N-DFUN-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)) 
-(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))|)) 
+     (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)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
-   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (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) (T) (T) (T) (T))
-    (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION)) 
+   (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 ((T) (T) (STRUCTURE) (T)) NIL)
-   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
+   (FUNCTION ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) &REST T)
     (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
+     (T)
      (OR
       (OR
        (OR
@@ -3081,189 +3417,58 @@
         (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) (T) (T))
-    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
-   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
-(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))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::SAUT-AND)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
-(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 ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
-   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
-(PROCLAIM
- '(FTYPE
-   (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
-    ((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
-    ((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))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES))
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
-(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)) 
-(PROCLAIM
- '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-    (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION)) 
-(PROCLAIM '(FTYPE (FUNCTION (&REST T) (SYSTEM:TRUE)) PCL::TRUE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
-   PCL::COPY-CACHE-INTERNAL)) 
-(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) (T) (T) (T) (T) (T)) (VALUES &REST T))
-   WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1
-   PCL::MAKE-SHORT-METHOD-COMBINATION)) 
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::EXTRACT-DECLARATIONS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((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)) 
+    ((STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::COPY-DEFAULT-METHOD-ONLY)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
+    ((T)
+     (OR
+      (BROADCAST-STREAM) (CONCATENATED-STREAM) (ECHO-STREAM)
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
+       (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::MAP-SPECIALIZERS PCL::MAP-ALL-GENERIC-FUNCTIONS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (NULL)) ITERATE::MAYBE-WARN
-   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CHECKING)) (T)) PCL::CHECKING-CACHE
-   PCL::CHECKING-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
-   PCL::FALSE)) 
-(PROCLAIM
- '(FTYPE
-   (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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
-   PCL::CACHE-VECTOR)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
-   PCL::COPY-METHOD-CALL)) 
+   PCL::PRINT-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T) &REST T)
     (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)) 
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::PRECOMPUTE-EFFECTIVE-METHODS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
-   PCL::POWER-OF-TWO-CEILING)) 
+    ((T) (T) &REST T)
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
+   PCL::MAKE-N-N-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
-   PCL::COPY-NO-METHODS)) 
+   (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) (T) (T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MEMF-CODE-CONVERTER)) 
+   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
+   PCL::BOOTSTRAP-SLOT-INDEX)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) (T) (T) (T)) (SYSTEM:TRUE))
@@ -3272,62 +3477,27 @@
    PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
-    (INTEGER 0 9223372036854775807))
-   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (VALUES (T) (T))) PCL::COMPUTE-CODE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
-   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|)) 
-(PROCLAIM
- '(FTYPE
-   (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)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (T))
-   PCL::LOAD-DEFMETHOD-INTERNAL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::PARSE-QUALIFIER-PATTERN)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (VALUES (T) (T) (T)))
-   PCL::PARSE-METHOD-OR-SPEC)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
-   PCL::COMPUTE-LINE-SIZE)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 7)) PCL::CACHE-FIELD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
-   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
+    ((T) (T) (T) (T) (T))
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
-    (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
+    ((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)) (STRUCTURE PCL::PV-TABLE))
-   PCL::MAKE-PV-TABLE-INTERNAL)) 
+   (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)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((SYSTEM:STD-INSTANCE) (T)) (T))
@@ -3335,210 +3505,37 @@
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
-    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
-   PCL::CHANGE-CLASS-INTERNAL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (T))
-   PCL::LOAD-DEFMETHOD)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((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) (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::NO-METHODS))
-   PCL::NO-METHODS-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (T)) WALKER::RELIST WALKER::RELIST*
-   FIND-CLASS PCL::ALLOCATE-STANDARD-INSTANCE
-   PCL::ALLOCATE-STRUCTURE-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) (T) (NULL) (T)) (T))
-   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES &OPTIONAL (T) (T) (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
-   PCL::CACHE-MISS-VALUES)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
-(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))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    (&REST T)
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::MAKE-PROGN)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
-   PCL::|__si::MAKE-CACHING|)) 
-(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))|)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHING)) (T)) PCL::CACHING-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((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)) (OR (INTEGER 0 12) (MEMBER NIL)))
-   PCL::WRAPPER-FIELD)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CHECKING)) (STRUCTURE PCL::CHECKING))
-   PCL::COPY-CHECKING)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((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 NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::RESET-INITIALIZE-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (STRUCTURE PCL::ARG-INFO)))
-   PCL::TYPES-FROM-ARGUMENTS)) 
-(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))|)) 
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))
+     (MEMBER NIL)))
+   PCL::METHODS-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
-    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
-   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (T)) PCL::ONE-INDEX-CACHE
-   PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-ACCESSOR-TYPE)) 
-(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::|(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)) 
+    ((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 NIL (VALUES)) PCL::COUNT-ALL-DFUNS)) 
 (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)) 
\ No newline at end of file
+   (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)) 
\ No newline at end of file
--- gcl27-2.7.0.orig/unixport/boot.lisp
+++ gcl27-2.7.0/unixport/boot.lisp
@@ -13,14 +13,16 @@
 					;maplist member member-if member-if-not
 					;assoc assoc-if assoc-if-not
 					;rassoc rassoc-if rassoc-if-not
-				       )
+				  )
+		      #+pre-gcl '(si::s-data-raw si::s-data-slot-position si::s-data-slot-descriptions)
+		      '(info-p info-ref info-type info-flags info-ch info-ref-ccb info-ref-clb)
+		      '(var-p var-name var-flags var-kind var-ref var-ref-ccb var-loc var-dt var-type var-mt var-tag var-store)
 		      'si::(listp ibb ib typep <= coerce < > >= + - set-array 0-byte-array-self set-0-byte-array-self concatenate eql-is-eq)
-		      '(info-p info-ref info-type info-flags info-ch info-ref-ccb info-ref-clb c1constant-value-object
-			     var-p var-name var-flags var-kind var-ref var-ref-ccb var-loc var-dt var-type var-mt var-tag var-store
-			     c-array-rank c-array-dim c-array-elttype c-array-self c-array-hasfillp
-			     array-dimension array-row-major-index row-major-aref si::row-major-aset
-			     si::row-major-aref-int aref array-rank array-total-size
-			     array-has-fill-pointer-p length memoized-hash-equal)))
+		      '(c1constant-value-object
+			c-array-rank c-array-dim c-array-elttype c-array-self c-array-hasfillp
+			array-dimension array-row-major-index row-major-aref si::row-major-aset
+			si::row-major-aref-int aref array-rank array-total-size
+			array-has-fill-pointer-p length memoized-hash-equal)))
 
 (in-package :user)
 
--- gcl27-2.7.0.orig/unixport/init_raw.lsp.in
+++ gcl27-2.7.0/unixport/init_raw.lsp.in
@@ -64,7 +64,9 @@
   (load (make-pathname :name "tk-package" :type "lsp" :directory gtk))
   (load (make-pathname :name "gcl_lfun_list" :type "lsp" :directory cmpnew))
   (load (make-pathname :name "gcl_cmpopt" :type "lsp" :directory cmpnew))
-  (let ((x (make-pathname :name "gcl_cmpnopt" :type "lsp" :directory cmpnew)))
+  (let* ((b "gcl_cmpnopt")
+	 (e #+pre-gcl "_pre" #+(not (or pre-gcl pcl)) "" #+(and pcl (not ansi-cl)) "_pcl" #+ansi-cl "_ansi")
+	 (x (make-pathname :name (string-concatenate b e) :type "lsp" :directory cmpnew)))
     (when (probe-file x) (load x)))
   (load (make-pathname :name "gcl_auto_new" :type "lsp" :directory lsp))
   
