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-31) unstable; urgency=medium
 .
   * Version_2_7_0pre34
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-01-17

--- gcl27-2.7.0.orig/clcs/gcl_clcs_condition_definitions.lisp
+++ gcl27-2.7.0/clcs/gcl_clcs_condition_definitions.lisp
@@ -113,7 +113,7 @@
   ((function-name :initarg :function-name
 		  :reader internal-condition-function-name
 		  :initform nil))
-  (:report (lambda (condition stream &aux (x (internal-condition-function-name condition)))
+  (: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)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpcall.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpcall.lsp
@@ -45,67 +45,6 @@
 (defun cmp-macro-function (name &aux (fun (local-fun-obj name)))
   (if fun (unless (fun-src fun) (fun-fn fun)) (macro-function name)))
 
-;; (defun sf (s)
-;;   (declare (optimize (safety 1)))
-;;   (check-type s symbol)
-;;   (or (let ((x (c::symbol-sfdef s)))
-;; 	(unless (= x (si::address nil)) (cons 'special x)))
-;;       (let ((x (c::symbol-gfdef s)))
-;; 	(when (= 0 (si::address x))
-;; 	  (error 'undefined-function s))
-;; 	(if (= (c::symbol-mflag s) 0) x (cons 'macro x)))))
-
-;; (defun funcallable-symbol-p (s)
-;;   (and (symbolp s)
-;;        (/= (si::address (c::symbol-gfdef s)) 0)
-;;        (= (c::symbol-mflag s) 0)
-;;        (= (c::symbol-sfdef s) (si::address nil))))
-;; (declaim (inline funcallable-symbol-p))
-;; (deftype funcallable-symbol nil `(satisfies funcallable-symbol-p))
-
-;; (defun fsf (s)
-;;   (declare (optimize (safety 1)))
-;;   (check-type s funcallable-symbol)
-;;   (c::symbol-gfdef s))
-;; (declaim (inline fsf))
-
-;; (defun c1funob (fun &aux sym)
-;;   ;;; NARGS is the number of arguments.  If the number is unknown, (e.g.
-;;   ;;; in case of APPLY), then NARGS should be NIL.
-;;   (cond ((and (consp fun)
-;; 	      (symbolp (car fun))
-;; 	      (cmp-macro-function (car fun)))
-;; 	 (setq fun (cmp-macroexpand fun))))
-;;   (or
-;;    (and
-;;     (consp fun)
-;;     (or (and (eq (car fun) 'quote)
-;;              (not (endp (cdr fun)))
-;;              (endp (cddr fun))
-;;              (or 
-;;                  (and (symbolp (cadr fun))
-;;                       (or (c1local-fun (cadr fun))
-;;                           (list 'call-global
-;;                                 (make-info :type (get-return-type (cadr fun))
-;;                                  :sp-change (if (null (get (cadr fun) 'no-sp-change)) 1 0))
-;;                                 (cadr fun)))
-;;                       )))
-;;         (and (eq (car fun) 'function)
-;;              (not (endp (cdr fun)))
-;;              (endp (cddr fun))
-;;              (or 
-;;                  (and (setq sym (si::funid-sym-p (cadr fun)))
-;;                       (or (c1local-fun sym)
-;;                           (list 'call-global
-;;                                 (make-info :type (get-return-type sym)
-;;                                  :sp-change (if (null (get sym 'no-sp-change)) 1 0))
-;;                                 sym))
-;;                       )))))
-;;    (let* ((x (c1expr (let ((x (tmpsym))) `(let ((,x ,fun)) (if (symbolp ,x) (fsf ,x) ,x)))))
-;; 	  (info (make-info :type (get-return-type fun) :sp-change 1)))
-;;         (add-info info (cadr x))
-;;         (list 'ordinary info x))))
-
 
 (defun c2funcall-aux(form &aux (funob (caddr form)) (args (cadddr form)))
   (c2funcall funob args))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpeval.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpeval.lsp
@@ -600,9 +600,11 @@
 (defun comment (x) x)
 (defun c1comment (args)
   (list 'comment (make-info :type t  :flags (iflags side-effects))
-	(with-output-to-string (s) (princ (car args) s))))
-(defun c2comment (comment)
-  (wt-nl "/*" (mysub (mysub comment "/*" "_*") "*/" "*_") "*/"))
+	(let ((x (car args)))
+	  (if (constantp x) (cmp-eval x) x))))
+(defun c2comment (comment &aux (comment-string (comment-string comment)))
+  (when *annotate*
+    (wt-nl "/*")(princ comment-string *compiler-output1*)(wt "*/")))
 (si::putprop 'comment 'c1comment 'c1)
 (si::putprop 'comment 'c2comment 'c2)
 
@@ -617,10 +619,14 @@
 
 (defvar *annotate* nil)
 
-(defun c2inline (comment expr &aux (comment (mysub (mysub (write-to-string comment :length 3 :level 3) "/*" "") "*/" "")))
-  (when *annotate* (wt-nl "/*")(princ comment *compiler-output1*)(wt "*/"))
+(defun comment-string (comment)
+  (when *annotate*
+    (mysub (mysub (write-to-string comment :length 3 :level 3) "/*" "_*") "*/" "*_")))
+
+(defun c2inline (comment expr &aux (comment-string (comment-string comment)))
+  (when *annotate* (wt-nl "/*")(princ comment-string *compiler-output1*)(wt "*/"))
   (c2expr expr)
-  (when *annotate* (wt-nl "/* END ")(princ comment *compiler-output1*)(wt "*/")))
+  (when *annotate* (wt-nl "/* END ")(princ comment-string *compiler-output1*)(wt "*/")))
 (si::putprop 'inline 'c1inline 'c1)
 (si::putprop 'inline 'c2inline 'c2)
 
@@ -1000,12 +1006,23 @@
 	  ((when (consp tp) (eq (car tp) 'or))
 	   (not (member-if-not (lambda (x) (discrete-tp x (incf i))) (cdr tp)))))))
 
+;; This function regulates the heuristic balance between compiler
+;; speed and type precision primarily via tagbody iteration.  The
+;; algorithm is essentially a guess at a surrounding type which might
+;; not be overflowed on subsequent compilation iteration.  More
+;; sophisticated ideas include bumping based on the type increment
+;; instead of the type-or, and collecting bounding information during
+;; the compilation pass.  Type inferencing on the branch pivot is not
+;; currently effective mostly because they are frequently not
+;; available on the first pass e.g. with atomic integer types.
+;; Several GCL programs nest tagbodys very deeply (e.g. axiom/fricas),
+;; so even a single extra iteration can be exponentially expensive.
 (defun bbump-tp (tp)
   (cond ((car (member tp '(#tnull
-			   #t(and seqbnd (not (integer 0 0)))
-			   #tseqbnd
-			   #t(or null (and seqbnd (not (integer 0 0))))
-			   #t(or null seqbnd))
+			   #t(and fixnum (integer 1))
+			   #t(and fixnum (integer 0))
+			   #t(or null (and fixnum (integer 1)))
+			   #t(or null (and fixnum (integer 0))))
 		      :test 'type<=)))
 	((discrete-tp tp) tp)
 	((bump-tp tp))))
@@ -1616,6 +1633,8 @@
 
 
 (defun mi5 (fn info fms la &aux (ll (when la (list (length fms)))) fd)
+  (when (iflag-p (info-flags info) side-effects)
+    (c1side-effects nil))
   (mi6 fn fms)
   (let ((r (assoc fn *recursion-detected*))) (when r (setf (cdr r) t)))
   (cond	((consp fn) 
@@ -2216,97 +2235,6 @@
 	  ,(make-info :type (or (ltvp val) (object-type (if (functionp val) (afe (cons 'df nil) (mf (fle val))) val))))
 	  ,l))))))
 
-;; (defun c1constant-value (val always-p &aux (val (if (exit-to-fmla-p) (not (not val)) val)))
-;;   (cond
-;;    ((eq val nil) (c1nil))
-;;    ((eq val t) (c1t))
-;;    ((typep val 'char)
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'CHAR-VALUE nil val)))
-;;    ((si:fixnump val)
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'FIXNUM-VALUE (unless (si::seqindp val) (add-object val)) val)))
-;;    ((characterp val)
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'CHARACTER-VALUE nil (char-code val))))
-;;    ((typep val 'long-float)
-;;     ;; We can't read in long-floats which are too big:
-;;     (let* (sc 
-;; 	   (vv 
-;; 	    (cond ((= val +inf) (add-object (cons 'si::|#,| `(symbol-value ','+inf))));This cannot be a constant list
-;; 		  ((= val -inf) (add-object (cons 'si::|#,| `(symbol-value ','-inf))))
-;; 		  ((not (isfinite val)) (add-object (cons 'si::|#,| `(symbol-value ','nan))))
-;; 		  ((> (abs val) (/ most-positive-long-float 2))
-;; 		   (add-object (cons 'si::|#,| `(* ,(/ val most-positive-long-float) most-positive-long-float))))
-;; 		  ((< 0.0 (abs val) (* least-positive-long-float 1.0d20))
-;; 		   (add-object (cons `si::|#,| `(* ,(/ val least-positive-long-float) least-positive-long-float))))
-;; 		  ((setq sc t) (add-object val)))))
-;; ;      (unless (isfinite val) (setf (info-type info) #tlong-float))
-;;       `(location ,(make-info :type (object-type val)) ,(if sc `(long-float-value ,vv ,val) `(vv ,vv)))))
-;;    ((typep val 'short-float)
-;;     (list 'LOCATION (make-info :type (object-type val))
-;;           (list 'SHORT-FLOAT-VALUE (add-object val) val)))
-;;    ((typep val #tfcomplex)
-;;     (list 'LOCATION (make-info :type (object-type val))
-;;           (list 'FCOMPLEX-VALUE (add-object val) val)))
-;;    ((typep val #tdcomplex)
-;;     (list 'LOCATION (make-info :type (object-type val))
-;;           (list 'DCOMPLEX-VALUE (add-object val) val)))
-;;    ((and (consp val) (eq (car val) 'si::|#,|))
-;; ;    (setf (info-type info) t);(object-type (cmp-eval (cdr val))))
-;;     (list 'LOCATION (make-info :type t) (list 'VV (add-object val))))
-;;    ((and *compiler-compile* (not *keep-gaz*))
-;; ;    (setf (info-type info) (object-type val))
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'VV (add-object (cons 'si::|#,| `(si::nani ,(si::address val)))))))
-;;    ((and (arrayp val) (not (si::staticp val)) (eq (array-element-type val) t)) ;; This must be readable
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'VV (add-object val))))
-;;    (always-p
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'VV (add-object val))))))
-
-;; (defun c1constant-value (val always-p); &aux (info (make-info :type (object-type val))))
-;; ;							    :referred-array +empty-info-array+
-;; ;							    :changed-array +empty-info-array+)))
-;;   (cond
-;;    ((eq val nil) (c1nil))
-;;    ((eq val t) (c1t))
-;;    ((typep val 'char)
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'CHAR-VALUE nil val)))
-;;    ((si:fixnump val)
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'FIXNUM-VALUE (unless (si::seqindp val) (add-object val)) val)))
-;;    ((characterp val)
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'CHARACTER-VALUE nil (char-code val))))
-;;    ((typep val 'long-float)
-;;     ;; We can't read in long-floats which are too big:
-;;     (let* (sc 
-;; 	   (vv 
-;; 	    (cond ((= val +inf) (add-object (cons 'si::|#,| `(symbol-value ','+inf))));This cannot be a constant list
-;; 		  ((= val -inf) (add-object (cons 'si::|#,| `(symbol-value ','-inf))))
-;; 		  ((not (isfinite val)) (add-object (cons 'si::|#,| `(symbol-value ','nan))))
-;; 		  ((> (abs val) (/ most-positive-long-float 2))
-;; 		   (add-object (cons 'si::|#,| `(* ,(/ val most-positive-long-float) most-positive-long-float))))
-;; 		  ((< 0.0 (abs val) (* least-positive-long-float 1.0d20))
-;; 		   (add-object (cons `si::|#,| `(* ,(/ val least-positive-long-float) least-positive-long-float))))
-;; 		  ((setq sc t) (add-object val)))))
-;; ;      (unless (isfinite val) (setf (info-type info) #tlong-float))
-;;       `(location ,(make-info :type (object-type val)) ,(if sc `(long-float-value ,vv ,val) `(vv ,vv)))))
-;;    ((typep val 'short-float)
-;;     (list 'LOCATION (make-info :type (object-type val))
-;;           (list 'SHORT-FLOAT-VALUE (add-object val) val)))
-;;    ((typep val #tfcomplex)
-;;     (list 'LOCATION (make-info :type (object-type val))
-;;           (list 'FCOMPLEX-VALUE (add-object val) val)))
-;;    ((typep val #tdcomplex)
-;;     (list 'LOCATION (make-info :type (object-type val))
-;;           (list 'DCOMPLEX-VALUE (add-object val) val)))
-;;    ((and (consp val) (eq (car val) 'si::|#,|))
-;; ;    (setf (info-type info) t);(object-type (cmp-eval (cdr val))))
-;;     (list 'LOCATION (make-info :type t) (list 'VV (add-object val))))
-;;    ((and *compiler-compile* (not *keep-gaz*))
-;; ;    (setf (info-type info) (object-type val))
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'VV (add-object (cons 'si::|#,| `(si::nani ,(si::address val)))))))
-;;    ((and (arrayp val) (not (si::staticp val)) (eq (array-element-type val) t)) ;; This must be readable
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'VV (add-object val))))
-;;    (always-p
-;;     (list 'LOCATION (make-info :type (object-type val)) (list 'VV (add-object val))))))
-					;FIXME check readability
-
 (defvar *compiler-temps*
         '(tmp0 tmp1 tmp2 tmp3 tmp4 tmp5 tmp6 tmp7 tmp8 tmp9))
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpfun.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpfun.lsp
@@ -231,7 +231,6 @@
 		 (c1t)))))
 	  (t (unless (and t1 t2) (setf (info-type info) nil)) `(call-global ,info ,nfn ,nargs)))))
 
-	   
 (dolist (l `(eq eql equal equalp))
   (si::putprop l 'do-eq-et-al 'c1g))
 
@@ -295,6 +294,40 @@
 (dolist (l `(>= > < <= = /=))
   (si::putprop l 'do-num-relations 'c1g))
 
+(defun do-+- (fn args)
+  (let* ((info (make-info :type #tnumber))
+	 (nargs (c1args args info))
+	 (i1 (info-type (cadar nargs)))
+	 (t1 (car (atomic-tp i1)))
+	 (i2 (info-type (cadadr nargs)))
+	 (t2 (car (atomic-tp i2))))
+    (cond ((and (eq fn 'number-plus) (eql t1 0) (ignorable-form (car nargs))) (cadr nargs));contagion
+	  ((and (eql t2 0) (ignorable-form (cadr nargs))) (car nargs))
+	  (t (setf (info-type info)
+		   (type-and (info-type info)
+			     (funcall (get fn 'type-propagator) fn i1 i2)))
+	     `(call-global ,info ,fn ,nargs)))))
+(setf (get 'number-plus 'c1g) 'do-+-)
+(setf (get 'number-minus 'c1g) 'do-+-)
+
+
+(defun do-*/ (fn args)
+  (let* ((info (make-info :type #tnumber))
+	 (nargs (c1args args info))
+	 (i1 (info-type (cadar nargs)))
+	 (t1 (car (atomic-tp i1)))
+	 (i2 (info-type (cadadr nargs)))
+	 (t2 (car (atomic-tp i2))))
+    (cond ((and (eq fn 'number-times) (eql t1 1) (ignorable-form (car nargs))) (cadr nargs));contagion
+	  ((and (eql t2 1) (ignorable-form (cadr nargs))) (car nargs))
+	  (t (setf (info-type info)
+		   (type-and (info-type info)
+			     (funcall (get fn 'type-propagator) fn i1 i2)))
+	     `(call-global ,info ,fn ,nargs)))))
+(setf (get 'number-times 'c1g) 'do-*/)
+(setf (get 'number-divide 'c1g) 'do-*/)
+
+
 (dolist (l `(eq eql equal equalp > >= < <= = /= length + - / * min max;FIXME get a good list here
 		car cdr caar cadr cdar cddr caaar caadr cadar cdaar caddr cdadr cddar cdddr 
 		caaaar caaadr caadar cadaar cdaaar caaddr cadadr cdaadr caddar cdadar cddaar
@@ -514,6 +547,7 @@
 		     (cond ;((get-vbind x))
 			   (atp (car atp));FIXME
 			   ((get-vbind x))
+			   ((lit-bind x))
 			   ((new-bind))))
 		    nargs)))
 ;    (when dot (setf (cdr (last y 2)) (car (last y)))) ;FIXME bump-pcons -- get rid of pcons entirely
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpif.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpif.lsp
@@ -239,10 +239,12 @@
 	       (let ((y (fmla-infer-tp (seventh fmla))))
 		 (setf (cdr x) (fmla-if1 nil (cdr x) y))))))
 	  (infer-tp (let* ((tp (info-type (cadr (fifth fmla))))
-			   (vl (third fmla))
+			   (vl (remove-if-not 'llvar-p (third fmla)))
 			   (i (cond ((type>= #tnull tp) (cons nil (fourth fmla)));FIXME nil tp
 				    ((type>= #t(not null) tp) (cons (fourth fmla) nil)))))
 		      (nconc (when i (mapcar (lambda (x) (cons x i)) vl)) (fmla-infer-tp (fifth fmla)))));FIXME
+	  (lit (mapcar (lambda (x) (list* x #t(not null) #tnull))
+		       (local-aliases (get-top-var-binding (lit-bind fmla)) nil)))
 	  (if (apply 'fmla-if (cddr fmla)))
 	  (var (when (llvar-p (car (third fmla)))
 		 (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
@@ -270,347 +272,6 @@
 		   ((fmla-default fmla)))))
 	  (otherwise (fmla-default fmla)))))
 
-;; (defun fmla-infer-tp (fmla)
-;;   (when (unless *compiler-new-safety* (listp fmla))
-;;     (case (car fmla)
-;; 	  (inline (fmla-infer-tp (fifth fmla)))
-;; 	  ((let let*) (remove-if (lambda (x) (member (car x) (third fmla))) (fmla-infer-tp (fifth fmla))))
-;; 	  (tagbody (mapc 'fmla-infer-tp (fifth fmla)) nil);FIXME need catch/throw here, and make this an ecase 
-;; 	  (block 
-;; 	   (let* ((tp (info-type (cadr (fourth fmla))))
-;; 		  (gen (list (cons +gen+ (cons (when (type-and #t(not null) tp) t) (when (type-and #tnull tp) t)))))
-;; 		  (*infer-tags* (cons (cons (third fmla) gen) *infer-tags*)))
-;; 	     (fmla-infer-tp (fourth fmla))
-;; 	     (labels ((fmla-walk (f) (cond ((atom f));FIXME now that this is in, maybe remove mapc in tagbody and switch
-;; 					   ((eq (car f) 'return-from) (fmla-infer-tp f))
-;; 					   (t (fmla-walk (car f)) (fmla-walk (cdr f))))))
-;; 		     (fmla-walk (fourth fmla)))
-;; 	     (cdar *infer-tags*)))
-;; 	  (progn (fmla-infer-tp (car (last (third fmla)))))
-;; 	  (decl-body (fmla-infer-tp (fourth fmla)))
-;; 	  (return-from 
-;; 	   (let ((x (assoc (third fmla) *infer-tags*)))
-;; 	     (when x (setf (cdr x) (fmla-if1 nil (cdr x) (fmla-infer-tp (seventh fmla)))))))
-;; 	  (switch
-;; 	   (mapc 'fmla-infer-tp (fourth fmla)) nil);FIXME
-;; 	  (infer-tp (let* ((tp (info-type (cadr (fifth fmla))))
-;; 			   (v (car (third (third fmla))))
-;; 			   (i (cond ((type>= #tnull tp) (list (list* v nil (fourth fmla))))
-;; 				    ((type>= #t(not null) tp) (list (list* v (fourth fmla) nil))))))
-;; 		      (append i (fmla-infer-tp (fifth fmla)))))
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  (call-global
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (car (third (first args))) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (car (third (first args))) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (car (third (first args)))
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (car (third (second args)))
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
-
-;; (defun fmla-infer-tp (fmla)
-;;   (when (unless *compiler-new-safety* (listp fmla))
-;;     (case (car fmla)
-;; 	  (inline (fmla-infer-tp (fifth fmla)))
-;; 	  ((let let*) (remove-if (lambda (x) (member (car x) (third fmla))) (fmla-infer-tp (fifth fmla))))
-;; 	  (tagbody (mapc 'fmla-infer-tp (fifth fmla)) nil);FIXME need catch/throw here, and make this an ecase 
-;; 	  (block 
-;; 	   (let* ((tp (info-type (cadr (fourth fmla))))
-;; 		  (gen (list (cons +gen+ (cons (when (type-and #t(not null) tp) t) (when (type-and #tnull tp) t)))))
-;; 		  (*infer-tags* (cons (cons (third fmla) gen) *infer-tags*)))
-;; 	     (fmla-infer-tp (fourth fmla))
-;; 	     (labels ((fmla-walk (f) (cond ((atom f));FIXME now that this is in, maybe remove mapc in tagbody and switch
-;; 					   ((eq (car f) 'return-from) (fmla-infer-tp f))
-;; 					   (t (fmla-walk (car f)) (fmla-walk (cdr f))))))
-;; 		     (fmla-walk (fourth fmla)))
-;; 	     (cdar *infer-tags*)))
-;; 	  (progn (fmla-infer-tp (car (last (third fmla)))))
-;; 	  (decl-body (fmla-infer-tp (fourth fmla)))
-;; 	  (return-from 
-;; 	   (let ((x (assoc (third fmla) *infer-tags*)))
-;; 	     (when x (setf (cdr x) (fmla-if1 nil (cdr x) (fmla-infer-tp (seventh fmla)))))))
-;; 	  (switch
-;; 	   (mapc 'fmla-infer-tp (fourth fmla)) nil);FIXME
-;; 	  (infer-tp (let ((tp (info-type (cadr (fifth fmla))))
-;; 			  (v (car (third (third fmla)))))
-;; 		      (cond ((type>= #tnull tp) (list (list* v nil (fourth fmla))))
-;; 			    ((type>= #t(not null) tp) (list (list* v (fourth fmla) nil))))))
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  (call-global
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (car (third (first args))) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (car (third (first args))) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (car (third (first args)))
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (car (third (second args)))
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
-
-;; (defun fmla-infer-tp (fmla)
-;;   (when (unless *compiler-new-safety* (listp fmla))
-;;     (case (car fmla)
-;; 	  (inline (fmla-infer-tp (fifth fmla)))
-;; 	  ((let let*) (remove-if (lambda (x) (member (car x) (third fmla))) (fmla-infer-tp (fifth fmla))))
-;; 	  (tagbody (mapc 'fmla-infer-tp (fifth fmla)) nil);FIXME need catch/throw here, and make this an ecase 
-;; 	  (block 
-;; 	   (let* ((tp (info-type (cadr (fourth fmla))))
-;; 		  (gen (list (cons +gen+ (cons (when (type-and #t(not null) tp) t) (when (type-and #tnull tp) t)))))
-;; 		  (*infer-tags* (cons (cons (third fmla) gen) *infer-tags*)))
-;; 	     (fmla-infer-tp (fourth fmla))
-;; 	     (cdar *infer-tags*)))
-;; 	  (progn (fmla-infer-tp (car (last (third fmla)))))
-;; 	  (decl-body (fmla-infer-tp (fourth fmla)))
-;; 	  (return-from 
-;; 	   (let ((x (assoc (third fmla) *infer-tags*)))
-;; 	     (when x (setf (cdr x) (fmla-if1 nil (cdr x) (fmla-infer-tp (seventh fmla)))))))
-;; 	  (switch
-;; 	   (mapc 'fmla-infer-tp (sixth fmla)) nil);FIXME
-;; 	  (infer-tp (let ((tp (info-type (cadr (fifth fmla))))
-;; 			  (v (car (third (third fmla)))))
-;; 		      (cond ((type>= #tnull tp) (list (list* v nil (fourth fmla))))
-;; 			    ((type>= #t(not null) tp) (list (list* v (fourth fmla) nil))))))
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  (call-global
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (car (third (first args))) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (car (third (first args))) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (car (third (first args)))
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (car (third (second args)))
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
-
-;; (defun fmla-infer-tp (fmla)
-;;   (when (unless *compiler-new-safety* (listp fmla))
-;;     (case (car fmla)
-;; 	  (inline (fmla-infer-tp (fifth fmla)))
-;; 	  ((let let*) (fmla-infer-tp (fifth fmla)))
-;; 	  (tagbody (mapc 'fmla-infer-tp (fifth fmla)));FIXME need catch/throw here, and make this an ecase 
-;; 	  (block 
-;; 	   (let ((*infer-tags* (cons (cons (third fmla) *gen-nil*) *infer-tags*)))
-;; 	     (fmla-infer-tp (fourth fmla))
-;; 	     (cdar *infer-tags*)))
-;; 	  (progn (fmla-infer-tp (car (last (third fmla)))))
-;; 	  (decl-body (fmla-infer-tp (fourth fmla)))
-;; 	  (return-from 
-;; 	   (let ((x (assoc (third fmla) *infer-tags*)))
-;; 	     (when x (setf (cdr x) (fmla-if1 nil (cdr x) (fmla-infer-tp (seventh fmla)))))))
-;; 	  (switch
-;; 	   (mapc 'fmla-infer-tp (sixth fmla)))
-;; 	  (infer-tp (let ((tp (info-type (cadr (fifth fmla))))
-;; 			  (v (car (third (third fmla)))))
-;; 		      (cond ((type>= #tnull tp) (list (list* v nil (fourth fmla))))
-;; 			    ((type>= #t(not null) tp) (list (list* v (fourth fmla) nil))))))
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  (call-global
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (car (third (first args))) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (car (third (first args))) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (car (third (first args)))
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (car (third (second args)))
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
-
-;; (defun fmla-infer-tp (fmla)
-;;   (when (unless *compiler-new-safety* (listp fmla))
-;;     (case (car fmla)
-;; 	  (inline (fmla-infer-tp (fifth fmla)))
-;; 	  ((let let*) (fmla-infer-tp (fifth fmla)))
-;; 	  (tagbody (mapc 'fmla-infer-tp (fifth fmla)));FIXME need catch/throw here, and make this an ecase 
-;; 	  (block 
-;; 	   (let ((*infer-tags* (cons (cons (third fmla) *gen-nil*) *infer-tags*)))
-;; 	     (fmla-infer-tp (fourth fmla))
-;; 	     (cdar *infer-tags*)))
-;; 	  (progn (fmla-infer-tp (car (last (third fmla)))))
-;; 	  (decl-body (fmla-infer-tp (fourth fmla)))
-;; 	  (return-from 
-;; 	   (let ((x (assoc (third fmla) *infer-tags*)))
-;; 	     (when x (setf (cdr x) (fmla-if1 nil (cdr x) (fmla-infer-tp (seventh fmla)))))))
-;; 	  (switch
-;; 	   (mapc 'fmla-infer-tp (sixth fmla)))
-;; 	  (infer-tp (let ((tp (info-type (cadr (fifth fmla)))))
-;; 		      (cond ((type>= #tnull tp) (list (list* (third fmla) nil (fourth fmla))))
-;; 			    ((type>= #t(not null) tp) (list (list* (third fmla) (fourth fmla) nil))))))
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  (call-global
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (car (third (first args))) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (car (third (first args))) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (car (third (first args)))
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (car (third (second args)))
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
-
-;; (defun fmla-infer-tp (fmla)
-;;   (when (unless *compiler-new-safety* (listp fmla))
-;;     (case (car fmla)
-;; 	  (inline (fmla-infer-tp (fifth fmla)))
-;; 	  ((let let*) (let* ((sl (mapcar 'cons (third fmla) (fourth fmla)));FIXME, sublis these alias bindings at the c1let* level
-;; 			     (ch (reduce 'union (mapcar (lambda (x) (info-ch (cadr x))) (append (fourth fmla) (list (fifth fmla))))))
-;; 			     (sl (remove-if (lambda (x) (or (member (car x) ch) (not (eq (cadr x) 'var)))) sl))
-;; 			     (sl (mapcar (lambda (x) (cons (car x) (car (third (cdr x))))) sl)))
-;; 			(sublis sl (fmla-infer-tp (fifth fmla)))))
-;; 	  (tagbody (mapc 'fmla-infer-tp (fifth fmla)));FIXME need catch/throw here, and make this an ecase 
-;; 	  (block 
-;; 	   (let ((*infer-tags* (cons (cons (third fmla) *gen-nil*) *infer-tags*)))
-;; 	     (fmla-infer-tp (fourth fmla))
-;; 	     (cdar *infer-tags*)))
-;; 	  (progn (fmla-infer-tp (car (last (third fmla)))))
-;; 	  (decl-body (fmla-infer-tp (fourth fmla)))
-;; 	  (return-from 
-;; 	   (let ((x (assoc (third fmla) *infer-tags*)))
-;; 	     (when x (setf (cdr x) (fmla-if1 nil (cdr x) (fmla-infer-tp (seventh fmla)))))))
-;; 	  (switch
-;; 	   (mapc 'fmla-infer-tp (sixth fmla)))
-;; 	  (infer-tp (let ((tp (info-type (cadr (fifth fmla)))))
-;; 		      (cond ((type>= #tnull tp) (list (list* (third fmla) nil (fourth fmla))))
-;; 			    ((type>= #t(not null) tp) (list (list* (third fmla) (fourth fmla) nil))))))
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (car (third fmla)) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  (call-global
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (car (third (first args))) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (car (third (first args))) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (car (third (first args)))
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (car (third (second args)))
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
-
-;; (defun fmla-infer-tp (fmla)
-;;   (unless *compiler-new-safety*
-;;     (case (car fmla)
-;; 	  (if (apply 'fmla-if (cddr fmla)))
-;; 	  (var (when (vlp fmla) (list (cons (var-name (car (third fmla))) (cons #t(not null) #tnull)))))
-;; 	  (setq (fmla-infer-tp (fourth fmla)));FIXME set var too, and in call global
-;; 	  ((inline call-global)
-;; 	   (let* ((fn (third fmla)) (rfn (cdr (assoc fn +bool-inf-op-list+)))
-;; 		  (sfn (cdr (assoc fn +bool-inf-sop-list+)))
-;; 		  (srfn (cdr (assoc sfn +bool-inf-op-list+)))
-;; 		  (args (if (eq (car fmla) 'inline) (fourth (fifth fmla)) (fourth fmla)))
-;; 		  (l (length args))
-;; 		  (pt (get fn 'si::predicate-type)));FIXME +cmp-type-alist+
-;; 	     (cond ((and (= l 1) (vlp (first args)) pt) 
-;; 		    (list (cons (vl-name (first args)) (cons (cmp-norm-tp pt) (cmp-norm-tp `(not ,pt))))))
-;; 		   ((and (= l 2) (eq fn 'typep) (vlp (first args))
-;; 			 (let ((tp (cmp-norm-tp (get-object-value (second args)))))
-;; 			   (when tp (list (cons (vl-name (first args)) (cons tp (cmp-norm-tp `(not ,tp)))))))))
-;; 		   ((and (= l 2) rfn)
-;; 		    (nconc
-;; 		     (when (vlp (first args))
-;; 		       (list (cons (vl-name (first args)) 
-;; 				   (tppra (vl-type (first args)) (second args) fn rfn))))
-;; 		     (when (vlp (second args))
-;; 		       (list (cons (vl-name (second args)) 
-;; 				   (tppra (vl-type (second args)) (first args) sfn srfn)))))))))
-;; 	  (otherwise
-;; 	   (cond ((consp (car fmla)) (fmla-infer-tp (car fmla)))
-;; 		 ((type>= #tnull (info-type (cadr fmla))) *gen-nil*)
-;; 		 ((type>= #t(not null) (info-type (cadr fmla))) *gen-t*))))))
 
 (defvar *restore-vars* nil)
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpinline.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpinline.lsp
@@ -67,11 +67,12 @@
     (unless i (baboon))
     `(logbitp ,i ,flags)))
 
-(defmacro iflags (&rest flags &aux (r 0))
-  (dolist (flag flags r)
-    (let ((i (position flag +iflags+)))
-      (unless i (baboon))
-      (setq r (logior r (ash 1 i))))))
+(defmacro iflags (&rest flags)
+  (the (unsigned-byte #.(length +iflags+))
+       (reduce (lambda (y x &aux (i (position x +iflags+)))
+		 (unless i (baboon))
+		 (logior y (ash 1 i)))
+	       flags :initial-value 0)))
 
 (defmacro copy-ht (ht)
   `(copy-list ,ht));nil ?
@@ -439,8 +440,8 @@
     (coerce-loc *value-to-go* type)))
     
 
-(defun lit-loc (tp inl args stores)
-  (declare (ignore stores))
+(defun lit-loc (tp inl args bind stores)
+  (declare (ignore bind stores))
   (let ((sig (list (mapcar (lambda (x) (info-type (cadr x))) args) tp))) 
     (get-inline-loc (list (car sig) (cadr sig) (flags rfa) inl) args)))
 
@@ -448,6 +449,14 @@
 ;;   (let* ((sig (list (mapcar (lambda (x) (info-type (cadr x))) args) tp))) 
 ;;     (get-inline-loc (list (car sig) (cadr sig) (flags rfa) inl) args)))
 
+(defun ub-loc (v &aux (c (car v)))
+  (ecase c
+      (var (cons c (caddr v)))
+      (lit (apply 'lit-loc (cddr v)))
+      (location (caddr v))
+      ((decl-body inline) (ub-loc (car (last v))))));FIXME
+
+
 (defun inline-args (forms types &optional fun &aux locs ii)
   (do ((forms forms (cdr forms))
        (types types (cdr types)))
@@ -495,12 +504,7 @@
 		      ((push (coerce-loc loc type) locs))))
 		 (push (wt-push-loc form type t) locs)))
 	      (lit (push (coerce-loc (apply 'lit-loc (cddr form)) type) locs))
-	      (ub (push (list 'gen-loc (caddr form) 
-			      (let* ((v (fourth form))(c (car v)))
-				(ecase c
-				       (var (cons c (caddr v)))
-				       (lit (apply 'lit-loc (cddr v)))
-				       (location (caddr v))))) locs))
+	      (ub (push (list 'gen-loc (caddr form) (ub-loc (fourth form))) locs))
               (structure-ref (push (coerce-loc-structure-ref (cdr form) type) locs))
               (SETQ
 	       (let* ((vref (caddr form))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpmulti.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpmulti.lsp
@@ -61,28 +61,6 @@
 		      :from-end t :initial-value `(funcall ,(car args) ,@syms)))))
 	  ((list 'multiple-value-call info (pop nargs) nargs)))))
 
-;; (defun c1multiple-value-call (args)
-;;   (when (endp args) (too-few-args 'multiple-value-call 1 0))
-;;   (let* ((nargs (c1args (cdr args) (make-info)))
-;; 	 (tps (mapcar (lambda (x) (info-type (cadr x))) nargs)))
-;;     (cond ((endp (cdr args)) (c1funcall args))
-;; 	  ((and (not (member-if-not 'nval tps))
-;; 		(inline-possible 'multiple-value-bind))
-;; 	   (let* ((n (reduce '+ (mapcar 'nval tps)))
-;; 		  (syms (mapcar (lambda (x) (declare (ignore x)) (tmpsym)) (make-list n)))
-;; 		  (r syms))
-;; 	     (c1expr
-;; 	      (reduce (lambda (x y) 
-;; 			(cond ((= 1 (length (car x)))
-;; 			       `(let ((,(caar x) ,(cadr x))) ,y))
-;; 			      (`(multiple-value-bind ,@x ,y))))
-;; 		      (mapcar (lambda (x y) (let* ((n (nval x)) syms)
-;; 					      (dotimes (i n) (push (pop r) syms))
-;; 					      (list (nreverse syms) y))) tps (cdr args))
-;; 		      :from-end t :initial-value `(funcall ,(car args) ,@syms)))))
-;; 	  ((let* ((info (make-info))
-;; 		  (nargs (c1args args info)))
-;; 	     (list 'multiple-value-call info (pop nargs) nargs))))))
 
 (defun c2multiple-value-call (funob forms &aux (*vs* *vs*) (loc (list 'vs (vs-push))) top sup)
 
@@ -218,6 +196,9 @@
   (unwind-exit 'fun-val nil (if top-data (car top-data))))
 
 (defun c1values (args &aux (info (make-info))(a (mapcar (lambda (x) (c1expr* x info)) args)))
+
+  (when (and a (not (cdr a)) (single-type-p (info-type (cadar a))))
+      (return-from c1values (car a)))
   (setf (info-type info)
 	(let ((x (mapcar (lambda (x) (coerce-to-one-value (info-type (cadr x)))) a)))
 	  (if (unless (cdr x) x) (car x) (cons 'returns-exactly x))));FIXME
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpopt.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpopt.lsp
@@ -183,27 +183,6 @@
 ;;   "@1;(#1)->lfa.lfa_self[(#2)*(#1)->a.a_dims[1]+#3]= (#0)")
 ;;    (get 'system:aset 'inline-unsafe))
 
-;;SYSTEM:CHAR-SET
- (push '((t t t) t #.(flags set)"elt_set(#0,fixint(#1),#2)")
-   (get 'system:char-set 'inline-always))
-(push '((t fixnum t) t #.(flags set)"elt_set(#0,#1,#2)")
-   (get 'system:char-set 'inline-always))
-(push '((t t t) t #.(flags set)
-  "@2;((#0)->ust.ust_self[fix(#1)]=char_code(#2),(#2))")
-   (get 'system:char-set 'inline-unsafe))
-(push '((t fixnum character) character #.(flags rfa set)"(code_char((#0)->ust.ust_self[#1]= char_code(#2)))")
-   (get 'system:char-set 'inline-unsafe))
-
-;;SYSTEM:ELT-SET
- (push '((t t t) t #.(flags set)"elt_set(#0,fixint(#1),#2)")
-   (get 'system:elt-set 'inline-always))
-(push '((t fixnum t) t #.(flags set)"elt_set(#0,#1,#2)")
-   (get 'system:elt-set 'inline-always))
-(push '((t t t) t #.(flags set)"elt_set(#0,fix(#1),#2)")
-   (get 'system:elt-set 'inline-unsafe))
-(push '((t fixnum t) t #.(flags set)"elt_set(#0,#1,#2)")
-   (get 'system:elt-set 'inline-unsafe))
-
 ;;SYSTEM:FILL-POINTER-SET
  (push '((t fixnum) seqind #.(flags rfa set)"(((#0)->st.st_fillp)=(((#0)->st.st_hasfillp) ? (#1) : ((#0)->st.st_fillp)))")
    (get 'system:fill-pointer-set 'inline-unsafe))
@@ -236,17 +215,6 @@
  (push '((t t t) t #.(flags set)"putprop(#0,#1,#2)")
    (get 'system:putprop 'inline-always))
 
-;;SYSTEM:SCHAR-SET
- (push '((t t t) t #.(flags set)"elt_set(#0,fixint(#1),#2)")
-   (get 'system:schar-set 'inline-always))
-(push '((t fixnum t) t #.(flags set)"elt_set(#0,#1,#2)")
-   (get 'system:schar-set 'inline-always))
-(push '((t t t) t #.(flags set)
-  "@2;((#0)->ust.ust_self[fix(#1)]=char_code(#2),(#2))")
-   (get 'system:schar-set 'inline-unsafe))
-(push '((t fixnum character) character #.(flags set rfa)"(code_char((#0)->ust.ust_self[#1]= char_code(#2)))")
-   (get 'system:schar-set 'inline-unsafe))
-
 ;;SYSTEM:SET-MV
  (push '((fixnum t) t #.(flags)"(MVloc[(#0)]=(#1))")
    (get 'system:set-mv 'inline-always))
@@ -428,14 +396,6 @@
 ;;CONS-CDR
 ; (push '((list) t #.(flags rfa)"(#0)->c.c_cdr") (get 'si::cons-cdr 'inline-always))
 
-;;CHAR
- (push '((t t) t #.(flags ans)"elt(#0,fixint(#1))")
-   (get 'char 'inline-always))
-(push '((t fixnum) t #.(flags ans)"elt(#0,#1)")
-   (get 'char 'inline-always))
-(push '((t t) character #.(flags rfa)"code_char((#0)->ust.ust_self[fix(#1)])")
-   (get 'char 'inline-unsafe))
-
 ;;CHAR-CODE
 ; (push '((character) fixnum #.(flags rfa)"(#0)")
 ;   (get 'char-code 'inline-always))
@@ -506,14 +466,6 @@
 ; (push '((character) (or null (integer 0 9)) #.(flags rfa)"@0; ((#0) <= '9' && (#0) >= '0')")
 ;   (get 'digit-char-p 'inline-always))
 
-;;ELT
- (push '((t t) t #.(flags ans)"elt(#0,fixint(#1))")
-   (get 'elt 'inline-always))
-(push '((t fixnum) t #.(flags ans)"elt(#0,#1)")
-   (get 'elt 'inline-always))
-;(push '((t t) t #.(flags ans)"elt(#0,fix(#1))")
-;   (get 'elt 'inline-unsafe))
-
 ;;ENDP
  (push '((t) boolean #.(flags rfa)"endp(#0)")
        (get 'endp 'inline-safe))
@@ -869,16 +821,6 @@
 (push '((fixnum fixnum) fixnum #.(flags rfa)"((#0)%(#1))")
    (get 'rem 'inline-always))
 
-;;SCHAR
- (push '((t t) t #.(flags ans)"elt(#0,fixint(#1))")
-   (get 'schar 'inline-always))
-(push '((t fixnum) t #.(flags ans)"elt(#0,#1)")
-   (get 'schar 'inline-always))
-(push '((t t) character #.(flags rfa)"code_char((#0)->ust.ust_self[fix(#1)])")
-   (get 'schar 'inline-unsafe))
-(push '((t fixnum) character #.(flags rfa)"code_char((#0)->ust.ust_self[#1])")
-   (get 'schar 'inline-unsafe))
-
 ;;SECOND
 ;;  (push '((t) t #.(flags)"cadr(#0)")
 ;;    (get 'second 'inline-safe))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpspecial.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpspecial.lsp
@@ -97,55 +97,6 @@
 (defvar *fun-tp-hash* (make-hash-table :test 'eq))
 
 (defvar *fn-src-fn* (make-hash-table :test 'eq))
-;; (defun funid-to-fn1 (funid)
-;;   (cond ((symbolp funid)
-;; 	 (cond ((local-fun-fn funid))
-;; 	       ((when (fboundp funid) (symbol-function funid)))
-;; 	       (funid (cmp-eval `(function (lambda (&rest r) 
-;; 					     (declare (:dynamic-extent r))
-;; 					     (apply ',funid r)))))))
-;; 	((gethash funid *fn-src-fn*))
-;; 	((setf (gethash funid *fn-src-fn*) (cmp-eval `(function ,funid))))))
-
-;; (defun funid-to-fn1 (funid)
-;;   (cond ((symbolp funid)
-;; 	 (cond ((local-fun-fn funid))
-;; 	       ((when (fboundp funid) (symbol-function funid)))
-;; 	       (funid (cmp-eval `(function (lambda (&rest r) 
-;; 					     (declare (:dynamic-extent r))
-;; 					     (apply ',funid r)))))))
-;; 	((cmp-eval `(function ,funid)))))
-
-;; (defun funid-to-fn (funid)
-;;   (let ((fn (funid-to-fn1 funid)))
-;;     (setf (gethash fn *fun-id-hash*) funid)
-;;     fn))
-
-;; (defun funid-to-fun1 (id)
-;;   (cond ((let ((id (si::funid-sym-p id)))
-;; 	   (cond ((local-fun-fun id))
-;; 		 ((when (fboundp id) (symbol-function id)))
-;; 		 (id (cmp-eval `(function (lambda (&rest r) 
-;; 					    (declare (:dynamic-extent r))
-;; 					    (apply ',id r))))))))
-;; 	((functionp id) id)
-;; 	((cmp-eval `(function ,id)))))
-
-;; (defun funid-to-fun (id)
-;;   (let ((fun (funid-to-fun1 id)))
-;;     (setf (gethash fun *fun-id-hash*) id)
-;;     fun))
-
-;; (defun portable-closure-src (fn) ;FIXME
-;;   (let* ((lam nil); (when (si::interpreted-function-p fn) (si::interpreted-function-lambda fn)))
-;; 	 (src (when lam (function-lambda-expression fn)))
-;; 	 (p (car (member-if-not 
-;; 		 (lambda (x) 
-;; 		   (eq x (car (member (var-name x) *vars* :key (lambda (x) (when (var-p x) (var-name x)))))))
-;; 		 (cadr lam)))))
-;;     (if p (keyed-cmpnote '(closure inline)
-;; 			 "Not inlining ~s due to redefinition of closure variable ~s." src (var-name p))
-;;       src)))
 
 (defun coerce-to-funid (fn)
   (cond ((symbolp fn) fn)
@@ -163,19 +114,6 @@
       (let* (car (member-if f (third l)))))))
 
 
-;; (defun find-special-var (l f &aux v)
-;;   (labels ((ccar (x) (when (listp x) (car x))))
-;; 	(cond ((funcall f l) l)
-;; 	      ((atom l) nil)
-;; 	      ((setq v (cadr (member 'bind-reg-clv l :key #'ccar)))
-;; 	       (when (eq 'let* (ccar v)) (find-special-var (caddr v) f)))
-;; 	      ((or (find-special-var (car l) f) (find-special-var (cdr l) f))))))
-
-;; (defun find-special-var (l f)
-;;   (cond ((funcall f l) l)
-;; 	((atom l) nil)
-;; 	((eq (car l) 'block) nil)
-;; 	((or (find-special-var (car l) f) (find-special-var (cdr l) f)))))
 
 (defun is-narg-le (l) (caadr (caddr l)))
 
@@ -214,10 +152,6 @@
 
 
 
-;; (defun process-local-fun-env (env b f fun tp)
-;;   (under-env env (process-local-fun b f fun tp)))
-
-
 (defun mc nil (let ((env (cons nil nil))) (lambda nil env)))
 
 (defun afe (a f)
@@ -227,11 +161,6 @@
 (defun fn-get (fn prop)
   (cdr (assoc prop (car (funcall fn)))))
 
-;; (defun mc nil (let (env) (lambda nil env)))
-
-;; (defun afe (a f)
-;;   (push a (car (fn-env f)))
-;;   f)
 
 (defun mf (id &optional fun)
   (let* ((f (mc)))
@@ -243,8 +172,6 @@
       (afe (cons 'df (current-env)) f))
     f))
 
-;; (defun fn-get (fn prop)
-;;   (cdr (assoc prop (car (fn-env fn)))))
 
 (defun funid-to-fn (funid &aux fun)
   (cond ((setq fun (local-fun-p funid)) (fun-fn fun))
@@ -254,9 +181,6 @@
 	((mf funid))
 	))
 
-;; (defun funid-to-fn (funid)
-;;   (or (local-fun-fn funid) (gethash funid *fn-src-fn*) (setf (gethash funid *fn-src-fn*) (mf funid))))
-
 
 (defvar *prov* nil)
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptop.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptop.lsp
@@ -893,14 +893,17 @@
 				args)))
 	    (when (eq tp :opaque) (baboon))
 	    (when (find #\= inl)
+	      (c1side-effects nil)
 	      (setf (info-flags info) (logior (iflags side-effects) (info-flags info))))
-	    (list 'lit info (info-type info) inl nargs (make-vs info))))))
+	    (let ((form (list 'lit info (info-type info) inl nargs nil (make-vs info))))
+	      (setf (sixth form) (new-bind form))
+	      form)))))
 
 
-(defun c2lit (tp inl args stores)
+(defun c2lit (tp inl args bind stores)
   (let* ((*inline-blocks* 0)
 	 (*restore-avma*  *restore-avma*))
-    (unwind-exit (lit-loc tp inl args stores) nil (cons 'values (if (equal tp #t(returns-exactly)) 0 1)))
+    (unwind-exit (lit-loc tp inl args bind stores) nil (cons 'values (if (equal tp #t(returns-exactly)) 0 1)))
     (close-inline-blocks)))
 
 ;; (defun c2lit (tp inl args)
@@ -967,7 +970,7 @@
 			     (info-ref (cadr l)))
 	  (third e) (list src clv name)
 	  (fourth e) *function-filename*
-	  (fifth e) (if (= (length clv) 0) 1 0)
+	  (fifth e) (logior (if (iflag-p (info-flags (cadr l)) side-effects) 0 2) (if (= (length clv) 0) 1 0))
 	  (sixth e) name)
     (when *sig-discovery*
       (when (symbol-package name) (unless (eq name 'lambda) (push (cons name (apply 'si::make-function-plist e)) si::*sig-discovery-props*))))
@@ -1150,7 +1153,7 @@
   (do* ((type (f-type return) (f-type (pop args)))
 	(i 0 (+ 2 i))
 	(ans type (logior ans (ash type i))))
-       ((or (>= i 32) (null args)) ans)))
+       ((or (>= i 32) (null args)) (the (unsigned-byte 32) ans))))
 
 (defun type-f (x)
   (declare (fixnum x))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptype.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptype.lsp
@@ -523,8 +523,10 @@
     (super-range f t1)))
 (si::putprop 'atan 'atan-propagator 'type-propagator)
 
-(defun float-propagator (f t1 &optional t2)
-  (super-range f (type-and #treal t1) (or t2 (type-and #tfloat t1) #t(member 0.0))))
+(defun float-propagator (f t1 &optional (t2 (or (type-and #tfloat t1) #t(member 0.0)))
+			 &aux (t1 (type-and #treal t1))(t2 (type-and #tfloat t2)))
+  (when (and t1 t2)
+    (super-range f t1 t2)))
 (setf (get 'float 'type-propagator) 'float-propagator)
 
 (defun bit-type (tp)
@@ -797,15 +799,24 @@
     (lit (carcdr-c1form-narg (car (fifth fm))))
     (ub (fourth fm))))
 
+(defun get-binding-form (b &aux (v (get-var b)))
+  (if v
+      (c1var v);FIXME? go through c1var when possible to pick up var-type
+      (let ((f (when (and (binding-p b) (binding-repeatable b)) (binding-form b))))
+	(when (check-vs (find-vs f))
+	  f))))
+
+
 (defun co1carcdr (f x);FIXME c1 prop?
   (let* ((c1form (mi1 f x))
 	 (narg (carcdr-c1form-narg c1form))
-	 (tp (when (and narg (ignorable-form narg)) (car (atomic-tp (info-type (cadr narg))))))
-	 (tp (when (consp tp) (funcall f tp)))
-	 (tp (get-var tp)))
-    (if tp (c1var tp) c1form)))
-
-
+	 (atp (when (and narg (ignorable-form narg)) (atomic-tp (info-type (cadr narg)))))
+	 (tp (car atp))
+	 (b (when (consp tp) (funcall f tp))))
+    (typecase b
+      (null c1form)
+      (binding (or (get-binding-form b) c1form))
+      (otherwise (atomic-type-constant-value atp)))))
 (setf (get 'car 'co1) 'co1carcdr)
 (setf (get 'cdr 'co1) 'co1carcdr)
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpvar.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpvar.lsp
@@ -210,6 +210,11 @@
 			    (bind-match x v))))
 		      vs)))
 
+(defun find-vs (form)
+  (case (car form)
+    ((var lit) (car (last form)))
+    ((inline decl-body) (find-vs (car (last form))))))
+
 (defun c1var (name)
   (let* ((info (make-info))
 	 (vref (c1vref name))
@@ -229,7 +234,7 @@
 	    ((when fmla (type>= #t(not null) (info-type info))) (c1t))
 	    ((let ((tmp (get-vbind-form (local-var vref))))
 	       (when (and tmp );FIXME (type>= (var-mt (car vref)) (var-mt (caaddr tmp)))
-		 (when (check-vs (when (eq 'var (car tmp)) (car (last tmp))))
+		 (when (check-vs (find-vs tmp));(when (eq 'var (car tmp)) (car (last tmp)))
 		   (let* ((f (pop tmp))(i (copy-info (pop tmp))))
 ;		     (setf (info-type i) (if (eq f 'var) (var-type (caar tmp)) (type-and (info-type i) (info-type info))));FIXME
 		     (setf (info-type i) (type-and (info-type i) (info-type info)))
@@ -286,20 +291,25 @@
     ((cons (eql var) t) (when (check-vs (car (last form)))  (local-var (caddr form))))
     (var form))))
 
+(defun lit-bind (x)
+  (when (consp x)
+    (case (car x)
+      (lit (sixth x))
+      ((inline decl-body) (lit-bind (car (last x)))))))
+
 (defun get-bind (x)
   (typecase
    x
    ((cons (eql var) t) (when (check-vs (car (last x))) (var-bind (local-var (caddr x)))))
+   ((cons (member inline decl-body) t) (get-bind (car (last x))))
+   ((cons (eql lit) t) (when (check-vs (car (last x))) (lit-bind x)))
    (var (var-bind x))
    (binding x)))
 
 (defun repeatable-var-binding (form)
   (case (car form)
-	(var form)
-	(location form)
-	;; (lit (unless (member-if (lambda (x) (when (stringp x) (>= (si::string-match #v"[a-zA-Z0-9]+\\(" x) 0))) form)
-	;;        form))
-	))
+	((var location lit) form)
+	((decl-body inline) (when (repeatable-var-binding (car (last form))) form))))
 
 (defun repeatable-binding-p (form &aux (i (cadr (repeatable-var-binding form))))
   (when i
--- gcl27-2.7.0.orig/git.tag
+++ gcl27-2.7.0/git.tag
@@ -1,2 +1,2 @@
-"Version_2_7_0pre33"
+"Version_2_7_0pre34"
 
--- gcl27-2.7.0.orig/h/compprotos.h
+++ gcl27-2.7.0/h/compprotos.h
@@ -19,7 +19,6 @@ object call_proc_cs2(object,...);
 object call_proc_new(object,ufixnum,ufixnum,void **,ufixnum,object,va_list);
 object call_proc_new_nval(object,ufixnum,ufixnum,void **,ufixnum,object,...);
 object coerce_to_string();
-object elt(object,int);
 object fixnum_big_shift(fixnum,fixnum);
 object fixnum_times(fixnum,fixnum);
 object fSgensym0(void);
--- gcl27-2.7.0.orig/h/protoize.h
+++ gcl27-2.7.0/h/protoize.h
@@ -1640,7 +1640,6 @@ object putprop(object,object,object);
 object read_object(object);
 object read_object_non_recursive(object);
 object make_symbol(object);
-object elt_set(object,int,object);
 object reverse(object);
 object alloc_bitvector(fixnum);
 object alloc_simple_bitvector(fixnum);
--- gcl27-2.7.0.orig/lsp/gcl_arraylib.lsp
+++ gcl27-2.7.0/lsp/gcl_arraylib.lsp
@@ -150,25 +150,32 @@
     bit))
 (declaim (inline set-0-byte-array-self))
 
-(defun array-row-major-index (array &rest indices)
-  (declare (dynamic-extent indices)(optimize (safety 2)))
+(defun array-row-major-index (array &rest indices &aux (k 1))
+  (declare (optimize (safety 1))(inline array-dimension)(rnkind k))
   (check-type array array)
-  (assert (apply 'array-in-bounds-p array indices));FIXME type-error??
-  (labels ((cpt (i j k l) (the seqind (if (zerop k) i (c+ i (c* j l)))));FIXME
-	   (armi-loop (s &optional (j 0) (k 0)) 
-		      (declare (rnkind k));FIXME
-		      (if s (armi-loop (cdr s) (cpt (car s) j k (array-dimension array k)) (1+ k)) j)))
-	  (armi-loop indices)))
+  (assert (apply 'array-in-bounds-p array indices))
+  (the seqind
+       (lreduce (lambda (y x &aux (z (array-dimension array k)))
+		  (declare (seqind x y))
+		  (incf k)
+		  (+ x (the seqind (c* y z))));FIXME * inline-args
+		(cdr indices) :initial-value (if indices (car indices) 0))))
 
 (defun aref (a &rest q)
   (declare (optimize (safety 1)) (dynamic-extent q))
   (check-type a array)
+  (if (and q (not (cdr q)))
+      (let ((x a))(check-type x vector))
+      (let ((x a))(check-type x matrix)))
   (row-major-aref a (apply 'array-row-major-index a q)))
 
 #-(and pre-gcl raw-image)
-(defun si::aset (v a &rest q)
+(defun aset (v a &rest q)
   (declare (optimize (safety 1)) (dynamic-extent q))
   (check-type a array)
+  (if (and q (not (cdr q)))
+      (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))
 
@@ -179,15 +186,15 @@
   (declare (optimize (safety 1)) (dynamic-extent i))
   (check-type a array)
   (unless (member-if-not (lambda (x) (<= 0 x (1- (array-dimension a (prog1 j (incf j)))))) i)
-       (= j (c-array-rank a))))
+       (eql j (c-array-rank a))))
 
 (defun array-dimension (x i)
   (declare (optimize (safety 2)))
   (check-type x array)
   (check-type i rnkind)
   (let ((r (c-array-rank x)));FIXME
-    (assert (< i r) (i) 'type-error :datum i :expected-type `(integer 0 (,r)))
-    (if (= 1 r) (c-array-dim x) (array-dims x i))));(the seqind (*fixnum (c-array-dims x) i nil nil))
+    (assert (< i r) () 'type-error :datum i :expected-type `(integer 0 (,r)))
+    (if (eql 1 r) (c-array-dim x) (array-dims x i))));(the seqind (*fixnum (c-array-dims x) i nil nil))
 
 (defun array-displacement (x)
   (declare (optimize (safety 1)))
@@ -268,6 +275,33 @@
   (check-type bit-array simple-bit-array)
   (apply 'aref bit-array indices))
 
+(defun char (x i)
+  (declare (optimize (safety 2)))
+  (check-type x string)
+  (check-type i seqind)
+  (aref x i))
+
+(defun schar (x i)
+  (declare (optimize (safety 1)))
+  (check-type x simple-string)
+  (check-type i seqind)
+  (aref x i))
+
+(declaim (inline char-set))
+(defun char-set (x i v)
+  (declare (optimize (safety 1)))
+  (check-type x string)
+  (check-type i seqind)
+  (check-type v character)
+  (aset v x i))
+
+(declaim (inline schar-set))
+(defun schar-set (x i v)
+  (declare (optimize (safety 1)))
+  (check-type x simple-string)
+  (check-type i seqind)
+  (check-type v character)
+  (aset v x i))
 
 (defun vector-push (new-element vector)
   (declare (optimize (safety 1)))
@@ -417,7 +451,8 @@
   (cond
     ((tp>= #tvector x) #t(member 1))
     ((let ((d (atomic-tp-array-rank x)))
-      (when d (object-tp d))))
+       (when d (object-tp d))))
+    ((tp>= #tmatrix x) #t(and rnkind (not (eql 1))))
     ((tp>= #tarray x) #trnkind)))
 (setf (get 'c-array-rank 'type-propagator) 'array-rank-propagator)
 
--- gcl27-2.7.0.orig/lsp/gcl_iolib.lsp
+++ gcl27-2.7.0/lsp/gcl_iolib.lsp
@@ -438,20 +438,21 @@
 
 
 (defun read-sequence (seq strm &key (start 0) end
-			  &aux (l (listp seq))(seqp (when l (nthcdr start seq)))
-			  (cp (eq (stream-element-type strm) 'character)))
+		      &aux (l (listp seq))(seqp (when l (nthcdr start seq)))
+			(cp (eq (stream-element-type strm) 'character)))
   (declare (optimize (safety 1)));FIXME
   (check-type seq sequence)
   (check-type strm stream)
   (check-type start (integer 0))
   (check-type end (or null (integer 0)))
   (labels ((set-cons (x z) (check-type x cons) (setf (car x) z) (cdr x)))
-    (reduce (lambda (y x &aux (z (if cp (read-char strm nil 'eof) (read-byte strm nil 'eof))))
-		     (declare (seqind y)(ignorable x))
-		     (when (eq z 'eof) (return-from read-sequence y))
-		     (if l (setq seqp (set-cons seqp z)) (setf (aref seq y) z))
-		     (1+ y))
-	    seq :initial-value start :start start :end end)))
+    (the seqbnd
+	 (reduce (lambda (y x &aux (z (if cp (read-char strm nil 'eof) (read-byte strm nil 'eof))))
+		   (declare (seqind y)(ignorable x))
+		   (when (eq z 'eof) (return-from read-sequence y))
+		   (if l (setq seqp (set-cons seqp z)) (setf (aref seq y) z))
+		   (1+ y))
+		 seq :initial-value start :start start :end end))))
 
 
 (defun write-sequence (seq strm &key (start 0) end
--- gcl27-2.7.0.orig/lsp/gcl_lr.lsp
+++ gcl27-2.7.0/lsp/gcl_lr.lsp
@@ -11,57 +11,50 @@
 (eval-when
  (compile)
 
- (defmacro defbltin (n)
-  `(progn
-     (defun ,n (x)
-       (declare (fixnum x))
-       (the (integer 0 ,(integer-length most-positive-fixnum))
-	    (lit :fixnum ,(strcat "__builtin_" n "(") (:fixnum x) ")")))
-     (declaim (inline ,n))))
-
-(defmacro defp nil
-  (labels ((lcf (shft &optional res)
-		(if (> (abs shft) (integer-length most-positive-fixnum)) 
-		    (nreverse res)
-		  (lcf (ash shft 1) (cons `(x (+ x (ash x ,shft))) res))))
-	   (lc (pat shft)
+  (defmacro defbltin (n)
+    `(progn
+       (defun ,n (x)
+	 (declare (fixnum x))
+	 (the (integer 0 ,(integer-length most-positive-fixnum))
+	      (lit :fixnum ,(strcat "__builtin_" n "(") (:fixnum x) ")")))
+       (declaim (inline ,n))))
+
+  (defmacro defp nil
+    (labels ((lcf (shft &optional res)
+	       (if (> (abs shft) (integer-length most-positive-fixnum))
+		   (nreverse res)
+		   (lcf (ash shft 1) (cons `(x (+ x (ash x ,shft))) res))))
+	     (lc (pat shft)
 	       (if (> shft (integer-length most-positive-fixnum)) 
 		   pat
-		 (lc (logior pat (ash pat shft)) (ash shft 1)))))
-	  `(progn
-	     (defun popcount (x)
-	       (declare (non-negative-fixnum x))
-	       (let* ((x (- x (logand (ash x -1) ,(lc 5 4))))
-		      (x (+ (logand x ,(lc 3 4)) (logand (ash x -2) ,(lc 3 4))))
-		      (x (logand ,(lc 15 8) (+ x (ash x -4))))
-		      ,@(lcf -8))
-		 (logand x ,(1- (ash (1+ (integer-length most-positive-fixnum)) 1)))))
-	     (declaim (inline popcount)))))
-
-
- (defmacro defl* ((f d &optional r c c1 c2 (nn f)))
-   (let* ((b (symbol-name nn))
-	  (fb (intern (concatenate 'string (symbol-name f) "B2")))
-	  (ls (intern (concatenate 'string "LOG" b)))
-	  (s (cdr (assoc f '((eqv . &)(and . &)(ior . \|)(xor . ^)))))
-	  sa;FIXME
-;	  (sa (eq s '&))
-	  (f `(,s n1 n2))
-	  (f (if c `(~ ,f) f))
-	  (q `(let* ((n1f (typep n1 'fixnum))(n2f (typep n2 'fixnum))
-		     ,@(when sa 
-			 `((n1 (if (and n2f (not n1f)) (mpz_get_si n1) n1))
-			   (n2 (if (and n1f (not n2f)) (mpz_get_si n2) n2)))))
-		(if (,(if sa 'or 'and) n1f n2f) ,f (the integer (,fb n1 n2 ,c)))))
-	  (q (if r `(let ((z ,q)) (if r (apply ',ls z (car r) (cdr r)) z)) q)))
-     `(defun ,ls ,(if r `(&optional (n1 ,d) (n2 ,d) &rest r) `(n1 n2))
-	,@(when r `((declare (dynamic-extent r))))
-	(declare (optimize (safety 1)))
-	(check-type n1 integer)
-	(check-type n2 integer)
-	(let (,@(when c1 `((n1 (lognot n1))))
-	      ,@(when c2 `((n2 (lognot n2)))))
-	  ,q)))))
+		   (lc (logior pat (ash pat shft)) (ash shft 1)))))
+      `(progn
+	 (defun popcount (x)
+	   (declare (non-negative-fixnum x))
+	   (let* ((x (- x (logand (ash x -1) ,(lc 5 4))))
+		  (x (+ (logand x ,(lc 3 4)) (logand (ash x -2) ,(lc 3 4))))
+		  (x (logand ,(lc 15 8) (+ x (ash x -4))))
+		  ,@(lcf -8))
+	     (logand x ,(1- (ash (1+ (integer-length most-positive-fixnum)) 1)))))
+	 (declaim (inline popcount)))))
+
+  (defmacro defl* ((f d &optional r c c1 c2 (nn f)))
+    (let* ((b (symbol-name nn))
+	   (fb (intern (concatenate 'string (symbol-name f) "B2")))
+	   (ls (intern (concatenate 'string "LOG" b)))
+	   (s (cdr (assoc f '((eqv . &)(and . &)(ior . \|)(xor . ^)))))
+	   (f `(,s n1 n2))
+	   (f (if c `(~ ,f) f))
+	   (q `(if (and (typep n1 'fixnum) (typep n2 'fixnum)) ,f (the integer (,fb n1 n2 ,c))))
+	   (q (if r `(if r (apply ',ls ,q (car r) (cdr r)) ,q) q)))
+      `(defun ,ls ,(if r `(&optional (n1 ,d) (n2 ,d) &rest r) `(n1 n2))
+	 ,@(when r `((declare (dynamic-extent r))))
+	 (declare (optimize (safety 1)))
+	 (check-type n1 integer)
+	 (check-type n2 integer)
+	 (let (,@(when c1 `((n1 (lognot n1))))
+	       ,@(when c2 `((n2 (lognot n2)))))
+	   ,q)))))
 
 
 (defl* (and -1 t))
--- gcl27-2.7.0.orig/lsp/gcl_nr.lsp
+++ gcl27-2.7.0/lsp/gcl_nr.lsp
@@ -22,8 +22,7 @@
       (declare (optimize (safety 1)))
       (check-type n1 number)
       (check-type n2 number)
-      (let ((z (,fn2 n1 n2)))
-	(if r (apply ',fn z (car r) (cdr r)) z))))
+      (if r (apply ',fn (,fn2 n1 n2) (car r) (cdr r)) (,fn2 n1 n2))))
 
  (defmacro defmm ((fn c))
    `(defun ,fn (n1 &optional (n2 n1) &rest r) 
@@ -31,8 +30,7 @@
       (declare (optimize (safety 1)))
       (check-type n1 real)
       (check-type n2 real)
-      (let ((z (if (,c n1 n2) n1 n2)))
-	(if r (apply ',fn z (car r) (cdr r)) z))))
+      (if r (apply ',fn (if (,c n1 n2) n1 n2) (car r) (cdr r)) (if (,c n1 n2) n1 n2))))
 
   (defmacro defmd ((fn fn2 fn3))
    `(defun ,fn (n1 &optional (n2 n1 n2p) &rest r) 
@@ -41,8 +39,7 @@
       (check-type n1 number)
       (check-type n2 number)
       (if n2p
-	  (let ((z (,fn2 n1 n2)))
-	    (if r (apply ',fn z (car r) (cdr r)) z))
+	  (if r (apply ',fn (,fn2 n1 n2) (car r) (cdr r)) (,fn2 n1 n2))
 	(,fn ,fn3 n1)))))
 
 (defcomp (<  <2))
--- gcl27-2.7.0.orig/lsp/gcl_sc.lsp
+++ gcl27-2.7.0/lsp/gcl_sc.lsp
@@ -71,7 +71,9 @@
 	 (do ((i1 start1 (1+ i1))
 	      (i2 start2 (1+ i2)))
 	     ((or (>= i1 end1) (>= i2 end2) (not (,= (setq c1 (aref s1 i1)) (setq c2 (aref s2 i2)))))
-	      ,@body))))))
+	      ,@body)
+	   (declare (seqbnd i1 i2)))))));FIXME
+
 
  (defmacro defchr (n (comp key))
    `(defun ,n (c1 &optional (c2 c1 c2p) &rest r) 
@@ -276,21 +278,6 @@
   (check-type c character)
   (or (graphic-char-p c) (char= c #\Newline)))
 
-(defun char (x i)
-  (declare (optimize (safety 2)))
-  (check-type x string)
-  (check-type i seqind)
-  (aref x i))
-
-(defun schar (x i)
-  (declare (optimize (safety 1)))
-  (check-type x simple-string)
-  (check-type i seqind)
-  (aref x i))
-
-
-
-
 (defun string (x)
   (declare (optimize (safety 1)))
   (check-type x string-designator)
@@ -401,13 +388,13 @@
 ;; (defun seqindp (x)
 ;;   (typecase x (seqind t)))
 
+(declaim (inline fixnump))
 (defun fixnump (x)
   (typecase x (fixnum t)))
-(si::putprop 'fixnump t 'compiler::cmp-inline)
 
+(declaim (inline spicep))
 (defun spicep (x)
   (typecase x (spice t)))
-(si::putprop 'spicep t 'compiler::cmp-inline)
 
 
 (defun constantp (x &optional env)
--- gcl27-2.7.0.orig/lsp/gcl_seqlib.lsp
+++ gcl27-2.7.0/lsp/gcl_seqlib.lsp
@@ -39,11 +39,16 @@
   (declare (optimize (safety 1)))
   (check-type seq sequence)
   (check-type n seqind)
-  (labels ((err nil (error 'type-error :datum n :expected-type `(integer 0 (,(length seq))))))
-	  (if (listp seq)
-	      (let ((r (nthcdr n seq)))
-		(if r (car r) (err)))
-	    (if (< n (length seq)) (aref seq n) (err)))))
+  (assert (< n (length seq)) () 'type-error :datum n :expected-type `(integer 0 (,(length seq))))
+  (if (listp seq) (nth n seq) (aref seq n)))
+
+(declaim (inline elt-set))
+(defun elt-set (seq n v)
+  (declare (optimize (safety 1)))
+  (check-type seq sequence)
+  (check-type n seqind)
+  (assert (< n (length seq)) () 'type-error :datum n :expected-type `(integer 0 (,(length seq))))
+  (if (listp seq) (setf (nth n seq) v) (setf (aref seq n) v)))
 
 (defun nreverse (s)
   (declare (optimize (safety 1)))
--- gcl27-2.7.0.orig/lsp/gcl_setf.lsp
+++ gcl27-2.7.0/lsp/gcl_setf.lsp
@@ -217,7 +217,7 @@
 (defsetf tenth (x) (y) `(progn (rplaca (nthcdr 9 ,x) ,y) ,y))
 (defsetf rest (x) (y) `(progn (rplacd ,x ,y) ,y))
 (defsetf svref si:svset)
-(defsetf elt si:elt-set)
+(defsetf elt si::elt-set)
 (defsetf symbol-value set)
 (defsetf symbol-function si::fset)
 (defsetf macro-function (s &optional env) (v) `(let ((env ,env)) (declare (ignorable env)) (si:fset ,s (cons 'macro ,v)) ,v))
@@ -232,8 +232,8 @@
   `(si::sputprop ,a ,b (progn ,@l)))
 ;  `(si::sputprop ,a ,b ,(car (last l))))
 (defsetf nth (n l) (v) `(progn (rplaca (nthcdr ,n ,l) ,v) ,v))
-(defsetf char si:char-set)
-(defsetf schar si:schar-set)
+(defsetf char si::char-set)
+(defsetf schar si::schar-set)
 ;(defsetf bit aset-wrap)
 ;(defsetf sbit aset-wrap)
 (defsetf bit (x &rest r) (v) `(baset ,v ,x ,@r))
@@ -389,7 +389,7 @@
   (case type
     (list `(setf (nth ,index ,struct) ,newvalue))
 ;    (list `(si:rplaca-nthcdr ,struct ,index ,newvalue))
-    (vector `(si:elt-set ,struct ,index ,newvalue))
+    (vector `(si::elt-set ,struct ,index ,newvalue))
     (t `(si::structure-set ,struct ',type ,index ,newvalue))))
 
 (defun setf-expand (l env)
--- gcl27-2.7.0.orig/o/assignment.c
+++ gcl27-2.7.0/o/assignment.c
@@ -310,17 +310,9 @@ static object
 setf(object place, object form)
 {
 	object fun;
-	object *vs = vs_top;
-	void (*f)();
 	object args;
 	object x,result,y;
-	int i,nka=0;
-/*  	extern void siLaset(void); */
-/*  	extern void siLsvset(void); */
-	extern void siLelt_set();
-	extern void siLchar_set();
-/*  	extern void siLfill_pointer_set(void); */
-	extern void siLhash_set();
+	int i;
 
 	if (!consp(place)) {
 	  setq(place, result=Ieval1(form));
@@ -368,9 +360,12 @@ setf(object place, object form)
 	  return Ieval1(MMcons(find_symbol(str("ASET"),system_package),MMcons(form,args)));
 	if (fun == sLsvref)
 	  return Ieval1(MMcons(find_symbol(str("SVSET"),system_package),append(args,MMcons(form,Cnil))));
-	if (fun == sLelt) { f = siLelt_set; goto EVAL; }
-	if (fun == sLchar) { f = siLchar_set; goto EVAL; }
-	if (fun == sLschar) { f = siLchar_set; goto EVAL; }
+	if (fun == sLelt)
+	  return Ieval1(MMcons(find_symbol(str("ELT-SET"),system_package),append(args,MMcons(form,Cnil))));
+	if (fun == sLchar)
+	  return Ieval1(MMcons(find_symbol(str("CHAR-SET"),system_package),append(args,MMcons(form,Cnil))));
+	if (fun == sLschar)
+	  return Ieval1(MMcons(find_symbol(str("SCHAR-SET"),system_package),append(args,MMcons(form,Cnil))));
 	if (fun == sLfill_pointer) 
 	  return Ieval1(MMcons(find_symbol(str("FILL-POINTER-SET"),system_package),append(args,MMcons(form,Cnil))));
 	if (fun == sLgethash) 
@@ -418,18 +413,6 @@ setf(object place, object form)
 	}
 	return result;
 
-EVAL:
-	for (;!endp(args);args=args->c.c_cdr)
-	  eval_push(args->c.c_car);
-	/* if (f!=siLaset) eval_push(form); */
-	if (nka && vs_top-vs>nka) {
-	  vs[nka]=vs_base[0];
-	  vs_top=vs+nka+1;
-	}
-	nka=0;
-	vs_base = vs;
-	(*f)();
-	return vs_base[0];
 
 OTHERWISE:
 	vs_base = vs_top;
--- gcl27-2.7.0.orig/o/cfun.c
+++ gcl27-2.7.0/o/cfun.c
@@ -44,7 +44,7 @@ make_cfun(void (*self)(), object name, o
      data->cfd.cfd_size=size; 
    } else if (size) FEerror("Bad call to make_cfun",0); 
 
-   return fSinit_function(list(6,Cnil,Cnil,make_fixnum((fixnum)self),Cnil,Cnil,name),
+   return fSinit_function(list(6,Cnil,Cnil,make_fixnum((fixnum)self),Cnil,make_fixnum(0),name),
 			  feval_src,data,Cnil,-1,0,(((1<<6)-1)<<6)|(((1<<5)-1)<<12)|(1<<17)); 
 
 }
--- gcl27-2.7.0.orig/o/eval.c
+++ gcl27-2.7.0/o/eval.c
@@ -976,7 +976,7 @@ DEFUN("FSET-IN",object,fSfset_in,SI,3,3,
   
   object x;
 
-  x=fSinit_function(list(6,Cnil,Cnil,src,Cnil,Cnil,name),(void *)FFN(fSeval_src),Cnil,Cnil,-1,0,(((1<<6)-1)<<6)|(((1<<5)-1)<<12)|(1<<17));
+  x=fSinit_function(list(6,Cnil,Cnil,src,Cnil,make_fixnum(0),name),(void *)FFN(fSeval_src),Cnil,Cnil,-1,0,(((1<<6)-1)<<6)|(((1<<5)-1)<<12)|(1<<17));
   x->fun.fun_env=src_env;
   if (sym!=Cnil) fSfset(sym,x);
   RETURN1(x);
--- gcl27-2.7.0.orig/o/sequence.d
+++ gcl27-2.7.0/o/sequence.d
@@ -118,115 +118,6 @@ alloc_bitvector(fixnum l) {
 
 }
 
-LFD(Lelt)()
-{
-	check_arg(2);
-	vs_base[0] = elt(vs_base[0], fixint(vs_base[1]));
-	vs_popp;
-}
-
-object
-elt(object seq, int index) {
-
-  int i;
-
-  if (index < 0) {
-    TYPE_ERROR(make_fixnum(index),sSnon_negative_fixnum);
-    return Cnil;
-  }
-  switch (type_of(seq)) {
-  case t_cons:
-    for (i=index;i>0 && !endp(seq);i--,seq=seq->c.c_cdr);
-    if (endp(seq))
-      break;
-    return(seq->c.c_car);
-
-  case t_vector:
-  case t_bitvector:
-  case t_simple_vector:
-  case t_simple_bitvector:
-    if (index>=(i=VLEN(seq)))
-      break;
-    return(aref(seq, index));
-
-  case t_simple_string:
-  case t_string:
-    if (index>=(i=VLEN(seq)))
-      break;
-    return(code_char(seq->ust.ust_self[index]));
-
-  case t_symbol:
-    if (seq==Cnil) {
-      i=0;
-      break;
-    }
-  default:
-    TYPE_ERROR(seq,sLsequence);
-    return(Cnil);
-  }
-
-  TYPE_ERROR(make_fixnum(index),MMcons(sLinteger,MMcons(make_fixnum(0),MMcons(MMcons(make_fixnum(i),Cnil),Cnil))));
-  return(Cnil);
-
-}
-
-LFD(siLelt_set)()
-{
-	check_arg(3);
-	vs_base[0] = elt_set(vs_base[0], fixint(vs_base[1]), vs_base[2]);
-	vs_popp;
-	vs_popp;
-}
-
-object
-elt_set(object seq,int index,object val) {
-
-  int i;
-
-  if (index < 0) {
-    TYPE_ERROR(make_fixnum(index),sSnon_negative_fixnum);
-    return Cnil;
-  }
-  switch (type_of(seq)) {
-  case t_cons:
-    for (i=index;i>0 && !endp(seq);i--,seq=seq->c.c_cdr);
-    if (endp(seq))
-      break;
-    return(seq->c.c_car = val);
-
-  case t_vector:
-  case t_bitvector:
-  case t_simple_vector:
-  case t_simple_bitvector:
-    if (index>=(i=VLEN(seq)))
-      break;
-    return(aset(seq, index, val));
-
-  case t_simple_string:
-  case t_string:
-    if (index>=(i=VLEN(seq)))
-      break;
-    if (type_of(val) != t_character)
-      TYPE_ERROR(val,sLcharacter);
-    seq->st.st_self[index] = val->ch.ch_code;
-    return(val);
-
-  case t_symbol:
-    if (seq==Cnil) {
-      i=0;
-      break;
-    }
-
-  default:
-    TYPE_ERROR(seq,sLsequence);
-    return Cnil;
-
-  }
-
-  TYPE_ERROR(make_fixnum(index),MMcons(sLinteger,MMcons(make_fixnum(0),MMcons(MMcons(make_fixnum(i),Cnil),Cnil))));
-  return(Cnil);
-
-}
 
 @(defun subseq (sequence start &optional end &aux x)
 	int s, e;
@@ -669,8 +560,6 @@ object seq;
 void
 gcl_init_sequence_function()
 {
-	make_function("ELT", Lelt);
-	make_si_function("ELT-SET", siLelt_set);
 	make_function("SUBSEQ", Lsubseq);
 	make_function("COPY-SEQ", Lcopy_seq);
 	make_function("LENGTH", Llength);
--- gcl27-2.7.0.orig/o/string.d
+++ gcl27-2.7.0/o/string.d
@@ -274,31 +274,6 @@ object x;
 	return(Cnil);
 }
 
-@(defun char (s i)
-	int j;
-@
-	check_type_string(&s);
-	if (type_of(i) != t_fixnum)
-		illegal_index(s, i);
-	if ((j = fix(i)) < 0 || j >= s->st.st_dim)
-		illegal_index(s, i);
-	@(return `code_char(s->ust.ust_self[j])`)
-@)
-
-LFD(siLchar_set)()
-{
-	int j;
-
-	check_arg(3);
-	check_type_string(&vs_base[0]);
-	if (type_of(vs_base[1]) != t_fixnum)
-		illegal_index(vs_base[0], vs_base[1]);
-	if ((j = fix(vs_base[1])) < 0 || j >= vs_base[0]->st.st_dim)
-		illegal_index(vs_base[0], vs_base[1]);
-	check_type_character(&vs_base[2]);
-	vs_base[0]->st.st_self[j] = char_code(vs_base[2]);
-	vs_base += 2;
-}
 
 void
 get_string_start_end(str, start, end, ps, pe)
@@ -701,10 +676,6 @@ gcl_init_string_function()
 	sKstart = make_keyword("START");
 	sKend = make_keyword("END");
 
-	make_function("CHAR", Lchar);
-	make_si_function("CHAR-SET", siLchar_set);
-	make_function("SCHAR", Lchar);
-	make_si_function("SCHAR-SET", siLchar_set);
 	make_function("STRING=", Lstring_eq);
 	make_function("STRING-EQUAL", Lstring_equal);
 	make_function("STRING<", Lstring_l);
--- gcl27-2.7.0.orig/pcl/gcl_pcl_dlisp.lisp
+++ gcl27-2.7.0/pcl/gcl_pcl_dlisp.lisp
@@ -219,8 +219,8 @@
 (defun emit-miss (miss-fn args &optional applyp)
   (let ((restl (when applyp '(.lap-rest-arg.))))
     (if restl
-	`(values (apply ,miss-fn ,@args ,@restl))
-	`(values (funcall ,miss-fn ,@args ,@restl)))))
+	`(apply ,miss-fn ,@args ,@restl)
+	`(funcall ,miss-fn ,@args ,@restl))))
 
 (defun emit-checking-or-caching (cached-emf-p return-value-p metatypes applyp)
   (when (and (null *precompiling-lap*) *emit-function-p*)
--- gcl27-2.7.0.orig/pcl/gcl_pcl_slots.lisp
+++ gcl27-2.7.0/pcl/gcl_pcl_slots.lisp
@@ -131,9 +131,10 @@
 (defun slot-value (object slot-name)
   (let* ((class (class-of object))
 	 (slot-definition (find-slot-definition class slot-name)))
-    (if (null slot-definition)
-	(slot-missing class object slot-name 'slot-value)
-	(slot-value-using-class class object slot-definition))))
+    (values
+     (if (null slot-definition)
+	 (slot-missing class object slot-name 'slot-value)
+	 (slot-value-using-class class object slot-definition)))))
 
 (setf (gdefinition 'slot-value-normal) #'slot-value)
 
@@ -141,7 +142,7 @@
   (if (and (constantp slot-name-form)
 	   (let ((slot-name (eval slot-name-form)))
 	     (and (symbolp slot-name) (symbol-package slot-name))))
-      `(accessor-slot-value ,object-form ,slot-name-form)
+      `(values (accessor-slot-value ,object-form ,slot-name-form))
       `(slot-value-normal ,object-form ,slot-name-form)))
 
 (defun set-slot-value (object slot-name new-value)
@@ -159,7 +160,7 @@
   (if (and (constantp slot-name-form)
 	   (let ((slot-name (eval slot-name-form)))
 	     (and (symbolp slot-name) (symbol-package slot-name))))
-      `(accessor-set-slot-value ,object-form ,slot-name-form ,new-value-form)
+      `(values (accessor-set-slot-value ,object-form ,slot-name-form ,new-value-form))
       `(set-slot-value-normal ,object-form ,slot-name-form ,new-value-form)))
 
 ;(defconstant *optimize-slot-boundp* nil)
@@ -178,7 +179,7 @@
   (if (and (constantp slot-name-form)
 	   (let ((slot-name (eval slot-name-form)))
 	     (and (symbolp slot-name) (symbol-package slot-name))))
-      `(accessor-slot-boundp ,object-form ,slot-name-form)
+      `(values (accessor-slot-boundp ,object-form ,slot-name-form))
       `(slot-boundp-normal ,object-form ,slot-name-form)))
 
 (defun slot-makunbound (object slot-name)
--- gcl27-2.7.0.orig/pcl/sys-package.lisp
+++ gcl27-2.7.0/pcl/sys-package.lisp
@@ -1,26 +1,30 @@
 
 
-;;; Definitions for package WALKER of type ESTABLISH
-(COMMON-LISP::UNLESS
- (COMMON-LISP::FIND-PACKAGE "WALKER")
- (COMMON-LISP::MAKE-PACKAGE "WALKER" :USE '("COMMON-LISP")))
-
 ;;; Definitions for package SLOT-ACCESSOR-NAME of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "SLOT-ACCESSOR-NAME")
  (COMMON-LISP::MAKE-PACKAGE
   "SLOT-ACCESSOR-NAME" :USE '("COMMON-LISP") :NICKNAMES '("S-A-N")))
 
+;;; Definitions for package WALKER of type ESTABLISH
+(COMMON-LISP::UNLESS
+ (COMMON-LISP::FIND-PACKAGE "WALKER")
+ (COMMON-LISP::MAKE-PACKAGE "WALKER" :USE '("COMMON-LISP")))
+
 ;;; Definitions for package ITERATE of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "ITERATE")
- (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("WALKER" "COMMON-LISP")))
+ (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("COMMON-LISP" "WALKER")))
 
 ;;; Definitions for package PCL of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "PCL")
  (COMMON-LISP::MAKE-PACKAGE
-  "PCL" :USE '("CSTRUCT" "WALKER" "ITERATE" "COMMON-LISP")))
+  "PCL" :USE '("COMMON-LISP" "ITERATE" "WALKER" "CSTRUCT")))
+
+;;; Definitions for package SLOT-ACCESSOR-NAME of type EXPORT
+(COMMON-LISP::IMPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
+(COMMON-LISP::EXPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
 
 ;;; Definitions for package WALKER of type EXPORT
 (COMMON-LISP::IMPORT
@@ -40,10 +44,6 @@
    WALKER::VARIABLE-GLOBALLY-SPECIAL-P)
  "WALKER")
 
-;;; Definitions for package SLOT-ACCESSOR-NAME of type EXPORT
-(COMMON-LISP::IMPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
-(COMMON-LISP::EXPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
-
 ;;; Definitions for package ITERATE of type EXPORT
 (COMMON-LISP::IMPORT
  '(ITERATE::SUMMING
@@ -222,521 +222,6 @@
    PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION)
  "PCL")
 
-;;; Definitions for package WALKER of type SHADOW
-(COMMON-LISP::SHADOW 'COMMON-LISP::NIL "WALKER")
-(COMMON-LISP::SHADOWING-IMPORT 'COMMON-LISP::NIL "WALKER")
-(COMMON-LISP::IMPORT
- '(WALKER::DEFINE-WALKER-TEMPLATE
-   WALKER::*VARIABLE-DECLARATIONS* WALKER::NESTED-WALK-FORM
-   WALKER::VARIABLE-DECLARATION WALKER::WALK-FORM-EXPAND-MACROS-P
-   WALKER::VARIABLE-LEXICAL-P SYSTEM::MACRO WALKER::VARIABLE-SPECIAL-P
-   WALKER::WALK-FORM WALKER::MACROEXPAND-ALL
-   WALKER::VARIABLE-GLOBALLY-SPECIAL-P WALKER::DO/DO* COMMON-LISP::EXP
-   COMMON-LISP::DEFVAR COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
-   COMMON-LISP::DISASSEMBLE COMMON-LISP::DELETE-IF WALKER::REAL-BODY
-   COMMON-LISP::CONCATENATED-STREAM-STREAMS COMMON-LISP::CLASS-OF
-   WALKER::WALK-DO* WALKER::WALK-PROG/PROG* WALKER::DEFINITION
-   COMMON-LISP::NSUBST-IF-NOT COMMON-LISP::CIS COMMON-LISP::LOGAND
-   COMMON-LISP::BIT-EQV COMMON-LISP::MAKE-INSTANCES-OBSOLETE
-   COMMON-LISP::RANDOM COMMON-LISP::COPY-LIST WALKER::CALL
-   COMMON-LISP::KEYWORDP WALKER::DOC-STRING-P
-   COMMON-LISP::*BREAK-ON-SIGNALS* COMMON-LISP::CADAR
-   COMMON-LISP::MERGE-PATHNAMES COMMON-LISP::BOOLE-C2
-   COMMON-LISP::BIT-NOT COMMON-LISP::STANDARD-OBJECT
-   COMMON-LISP::STRINGP WALKER::LLIST COMMON-LISP::METHOD-COMBINATION
-   COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::CLOSE
-   COMMON-LISP::INTEGER-DECODE-FLOAT COMMON-LISP::PPRINT-NEWLINE
-   COMMON-LISP::CHAR-NOT-EQUAL WALKER::ARG WALKER::ARM1
-   COMMON-LISP::COSH COMMON-LISP::NTHCDR
-   COMMON-LISP::GET-UNIVERSAL-TIME COMMON-LISP::YES-OR-NO-P
-   WALKER::END-TEST COMMON-LISP::READ-LINE COMMON-LISP::LET*
-   WALKER::WALKER-ENVIRONMENT-BIND WALKER::OLD-ENV
-   COMMON-LISP::PATHNAME-TYPE COMMON-LISP::FLOAT-PRECISION
-   COMMON-LISP::PROG* WALKER::ENVIRONMENT-FUNCTION
-   COMMON-LISP::SYMBOL-NAME COMMON-LISP::LOG COMMON-LISP::OR
-   COMMON-LISP::PACKAGE-SHADOWING-SYMBOLS COMMON-LISP::BREAK
-   COMMON-LISP::STRUCTURE-OBJECT COMMON-LISP::ROTATEF COMMON-LISP::SQRT
-   COMMON-LISP::CONS COMMON-LISP::NSUBST-IF WALKER::POSSIBLE-BLOCK-NAME
-   COMMON-LISP::UNWIND-PROTECT COMMON-LISP::CONSP
-   COMMON-LISP::FLOAT-SIGN COMMON-LISP::SOME COMMON-LISP::MAPC
-   WALKER::BODY COMMON-LISP::SETF COMMON-LISP::CEILING
-   COMMON-LISP::&BODY COMMON-LISP::CDAR COMMON-LISP::STANDARD
-   COMMON-LISP::MAKE-LIST COMMON-LISP::MAKE-HASH-TABLE
-   COMMON-LISP::STRING-UPCASE COMMON-LISP::STRING-DOWNCASE
-   COMMON-LISP::STYLE-WARNING COMMON-LISP::ASINH COMMON-LISP::DEFCLASS
-   COMMON-LISP::NRECONC COMMON-LISP::NSTRING-DOWNCASE
-   COMMON-LISP::SECOND WALKER::ENV-DECLARATIONS WALKER::SEQUENTIALP
-   COMMON-LISP::RATIONALP COMMON-LISP::SET-DISPATCH-MACRO-CHARACTER
-   COMMON-LISP::GET-DISPATCH-MACRO-CHARACTER COMMON-LISP::CHECK-TYPE
-   COMMON-LISP::MAKE-STRING-INPUT-STREAM
-   COMMON-LISP::MAKE-STRING-OUTPUT-STREAM
-   WALKER::VARIABLE-SYMBOL-MACRO-P COMMON-LISP::SAFETY
-   COMMON-LISP::*READ-DEFAULT-FLOAT-FORMAT* COMMON-LISP::*LOAD-VERBOSE*
-   COMMON-LISP::OTHERWISE COMMON-LISP::NBUTLAST COMMON-LISP::ADD-METHOD
-   COMMON-LISP::PPRINT-EXIT-IF-LIST-EXHAUSTED COMMON-LISP::SORT
-   COMMON-LISP::WARNING WALKER::LOCK COMMON-LISP::DEFINE-COMPILER-MACRO
-   COMMON-LISP::PROGN COMMON-LISP::PUSHNEW WALKER::WALK-LET-IF
-   COMMON-LISP::CHAR= COMMON-LISP::MAKE-ECHO-STREAM
-   COMMON-LISP::BIT-AND WALKER::UNBOUND-LEXICAL-FUNCTION
-   COMMON-LISP::EXPORT WALKER::WALKER-TEMPLATE COMMON-LISP::EQ
-   COMMON-LISP::SOFTWARE-TYPE COMMON-LISP::LOGTEST
-   COMMON-LISP::LIST-ALL-PACKAGES COMMON-LISP::DEFTYPE
-   COMMON-LISP::GETF COMMON-LISP::ROW-MAJOR-AREF COMMON-LISP::TYPECASE
-   WALKER::EXPANSION COMMON-LISP::HASH-TABLE-TEST
-   COMMON-LISP::USER-HOMEDIR-PATHNAME COMMON-LISP::SYMBOL-PACKAGE
-   COMMON-LISP::BOOLEAN COMMON-LISP::HOST-NAMESTRING
-   COMMON-LISP::IN-PACKAGE COMMON-LISP::CAAR COMMON-LISP::INTERN
-   COMMON-LISP::CONDITION COMMON-LISP::LOGNOT COMMON-LISP::SUBST-IF-NOT
-   COMMON-LISP::COPY-READTABLE COMMON-LISP::REVAPPEND
-   COMMON-LISP::SYMBOL WALKER::REMOTE COMMON-LISP::BIT-VECTOR
-   COMMON-LISP::SEARCH WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
-   WALKER::INNER-NO-MORE-P COMMON-LISP::STREAM-ELEMENT-TYPE
-   COMMON-LISP::POP COMMON-LISP::SLOT-UNBOUND COMMON-LISP::GO
-   COMMON-LISP::LIST COMMON-LISP::*LOAD-PRINT* WALKER::MACRO-ENV
-   COMMON-LISP::SET-MACRO-CHARACTER COMMON-LISP::GET-MACRO-CHARACTER
-   COMMON-LISP::PARSE-ERROR COMMON-LISP::FILE-ERROR-PATHNAME
-   COMMON-LISP::CHANGE-CLASS COMMON-LISP::VALUES
-   COMMON-LISP::DESTRUCTURING-BIND COMMON-LISP::RANDOM-STATE
-   COMMON-LISP::LISTP COMMON-LISP::UPGRADED-COMPLEX-PART-TYPE
-   COMMON-LISP::CHAR/= WALKER::WALK-BINDINGS-1 COMMON-LISP::REMPROP
-   COMMON-LISP::DO COMMON-LISP::SYMBOL-MACROLET COMMON-LISP::ABS
-   COMMON-LISP::&KEY COMMON-LISP::VECTOR-PUSH-EXTEND
-   COMMON-LISP::DEFPACKAGE COMMON-LISP::PACKAGE-NICKNAMES
-   COMMON-LISP::MULTIPLE-VALUE-PROG1 WALKER::FN
-   COMMON-LISP::SYNONYM-STREAM-SYMBOL COMMON-LISP::RESTART-CASE
-   COMMON-LISP::END-OF-FILE COMMON-LISP::*DEFAULT-PATHNAME-DEFAULTS*
-   COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS COMMON-LISP::EXPT
-   WALKER::WALK-IF WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 WALKER::MACROP
-   COMMON-LISP::READER-ERROR COMMON-LISP::ABORT COMMON-LISP::CLASS-NAME
-   COMMON-LISP::REMHASH COMMON-LISP::BLOCK COMMON-LISP::PACKAGE-ERROR
-   COMMON-LISP::SIGNAL COMMON-LISP::PARSE-INTEGER COMMON-LISP::TIME
-   COMMON-LISP::COERCE COMMON-LISP::FIND-IF COMMON-LISP::UNREAD-CHAR
-   WALKER::WALK-DO/DO* COMMON-LISP::DOUBLE-FLOAT-EPSILON
-   COMMON-LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON COMMON-LISP::BOOLE-IOR
-   COMMON-LISP::ASSERT COMMON-LISP::ADJUSTABLE-ARRAY-P WALKER::TEST
-   COMMON-LISP::COPY-TREE COMMON-LISP::*PRINT-LINES* COMMON-LISP::DEBUG
-   WALKER::VAR COMMON-LISP::CLEAR-OUTPUT COMMON-LISP::CODE-CHAR
-   COMMON-LISP::STRING-CAPITALIZE COMMON-LISP::///
-   COMMON-LISP::WITH-OPEN-STREAM WALKER::WITH-AUGMENTED-ENVIRONMENT
-   COMMON-LISP::REST COMMON-LISP::ACOS COMMON-LISP::MACHINE-TYPE
-   WALKER::RELIST WALKER::DEFINITIONS COMMON-LISP::DENOMINATOR
-   COMMON-LISP::TRACE COMMON-LISP::PRINT-NOT-READABLE-OBJECT
-   COMMON-LISP::FLOATING-POINT-INEXACT COMMON-LISP::*READ-BASE*
-   COMMON-LISP::ENSURE-DIRECTORIES-EXIST COMMON-LISP::CDR
-   COMMON-LISP::STRING-EQUAL COMMON-LISP::HASH-TABLE-REHASH-THRESHOLD
-   WALKER::NEW-FORM COMMON-LISP::DELETE-FILE COMMON-LISP::FIRST
-   COMMON-LISP::ALPHANUMERICP COMMON-LISP::WITH-HASH-TABLE-ITERATOR
-   COMMON-LISP::SCALE-FLOAT COMMON-LISP::CONCATENATED-STREAM
-   COMMON-LISP::CONTROL-ERROR COMMON-LISP::FINISH-OUTPUT
-   COMMON-LISP::LAMBDA-PARAMETERS-LIMIT COMMON-LISP::PRINC
-   COMMON-LISP::ADJOIN COMMON-LISP::PI
-   COMMON-LISP::ARITHMETIC-ERROR-OPERATION COMMON-LISP::DOUBLE-FLOAT
-   COMMON-LISP::READTABLE COMMON-LISP::READTABLEP
-   COMMON-LISP::READ-SEQUENCE COMMON-LISP::FUNCTION-LAMBDA-EXPRESSION
-   COMMON-LISP::ARRAY-RANK-LIMIT COMMON-LISP::WRITE-SEQUENCE
-   WALKER::ENTRY COMMON-LISP::RENAME-FILE COMMON-LISP::READ-CHAR
-   COMMON-LISP::PEEK-CHAR COMMON-LISP::REMOVE-DUPLICATES
-   COMMON-LISP::BYTE COMMON-LISP::*MODULES*
-   COMMON-LISP::GET-OUTPUT-STREAM-STRING WALKER::*P
-   COMMON-LISP::DYNAMIC-EXTENT COMMON-LISP::LOOP-FINISH
-   COMMON-LISP::MULTIPLE-VALUE-BIND COMMON-LISP::VECTORP
-   COMMON-LISP::RASSOC-IF-NOT COMMON-LISP::UNINTERN COMMON-LISP::CDADAR
-   COMMON-LISP::FUNCTION WALKER::OUTER-NO-MORE-P COMMON-LISP::LOGORC2
-   COMMON-LISP::*PACKAGE* COMMON-LISP::STRING-NOT-GREATERP
-   COMMON-LISP::INTERSECTION WALKER::TAIL COMMON-LISP::SPACE
-   COMMON-LISP::SEVENTH COMMON-LISP::BASE-CHAR COMMON-LISP::NAME-CHAR
-   COMMON-LISP::SBIT COMMON-LISP::CAADAR COMMON-LISP::TAILP
-   COMMON-LISP::*TERMINAL-IO* COMMON-LISP::STREAM-ERROR
-   COMMON-LISP::BOOLE-ANDC1 COMMON-LISP::DO-ALL-SYMBOLS
-   COMMON-LISP::IGNORABLE COMMON-LISP::MAKUNBOUND COMMON-LISP::PROVIDE
-   COMMON-LISP::THROW COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS
-   COMMON-LISP::LENGTH COMMON-LISP::CDAAR COMMON-LISP::&AUX
-   COMMON-LISP::ARRAY-DISPLACEMENT COMMON-LISP::HANDLER-BIND
-   COMMON-LISP::PAIRLIS WALKER::FUNCTIONS COMMON-LISP::*PRINT-GENSYM*
-   COMMON-LISP::COMPILE-FILE-PATHNAME COMMON-LISP::CAR
-   COMMON-LISP::FTRUNCATE COMMON-LISP::DELETE-DUPLICATES
-   COMMON-LISP::NREVERSE COMMON-LISP::APROPOS
-   COMMON-LISP::STRING-RIGHT-TRIM COMMON-LISP::NO-NEXT-METHOD
-   COMMON-LISP::STEP COMMON-LISP::BIT-NOR COMMON-LISP::ARRAY-TOTAL-SIZE
-   COMMON-LISP::ECHO-STREAM COMMON-LISP::FMAKUNBOUND
-   COMMON-LISP::FUNCTION-KEYWORDS COMMON-LISP::SUBST-IF
-   COMMON-LISP::GET-DECODED-TIME COMMON-LISP::LONG-FLOAT
-   COMMON-LISP::SIMPLE-WARNING COMMON-LISP::RATIO COMMON-LISP::EVENP
-   COMMON-LISP::QUOTE WALKER::NEWNEWNEWFORM COMMON-LISP::SIMPLE-STRING
-   COMMON-LISP::NSUBSTITUTE COMMON-LISP::DESCRIBE-OBJECT
-   COMMON-LISP::LAST COMMON-LISP::NSET-DIFFERENCE COMMON-LISP::COUNT
-   COMMON-LISP::CDAAAR COMMON-LISP::SET-DIFFERENCE WALKER::RELIST*
-   WALKER::KEY-ARGS COMMON-LISP::PPRINT
-   COMMON-LISP::SHORT-FLOAT-EPSILON
-   COMMON-LISP::SHORT-FLOAT-NEGATIVE-EPSILON COMMON-LISP::ACOSH
-   COMMON-LISP::LISTEN COMMON-LISP::GENTEMP COMMON-LISP::ERROR
-   COMMON-LISP::ADJUST-ARRAY COMMON-LISP::ALLOCATE-INSTANCE
-   COMMON-LISP::IF COMMON-LISP::CAAAAR
-   COMMON-LISP::SET-SYNTAX-FROM-CHAR COMMON-LISP::STRING-TRIM
-   COMMON-LISP::DIGIT-CHAR COMMON-LISP::BOOLE-AND
-   COMMON-LISP::*COMPILE-PRINT* COMMON-LISP::STRING> COMMON-LISP::CAAAR
-   WALKER::ENV-WALK-FORM COMMON-LISP::GETHASH
-   COMMON-LISP::METHOD-QUALIFIERS COMMON-LISP::FILL-POINTER
-   COMMON-LISP::METHOD-COMBINATION-ERROR COMMON-LISP::CDADDR
-   COMMON-LISP::REMOVE-METHOD COMMON-LISP::DIRECTORY-NAMESTRING
-   COMMON-LISP::DEFUN COMMON-LISP::TRUNCATE WALKER::BLOCK-NAME
-   COMMON-LISP::ALPHA-CHAR-P COMMON-LISP::SYMBOL-FUNCTION
-   COMMON-LISP::SUBSTITUTE-IF-NOT COMMON-LISP::LDB-TEST
-   COMMON-LISP::FLOAT-DIGITS COMMON-LISP::BIT-VECTOR-P
-   COMMON-LISP::REINITIALIZE-INSTANCE COMMON-LISP::PRINT-OBJECT
-   COMMON-LISP::CAADDR COMMON-LISP::VARIABLE COMMON-LISP::NUMERATOR
-   COMMON-LISP::NOTINLINE COMMON-LISP::CHAR-LESSP COMMON-LISP::WARN
-   COMMON-LISP::TYPE-ERROR-DATUM COMMON-LISP::CHAR-NOT-LESSP
-   COMMON-LISP::ARRAY-DIMENSION-LIMIT COMMON-LISP::MOD
-   WALKER::INNER-RESULT COMMON-LISP::SXHASH
-   COMMON-LISP::STREAM-EXTERNAL-FORMAT COMMON-LISP::PACKAGE-USE-LIST
-   COMMON-LISP::PACKAGE-USED-BY-LIST COMMON-LISP::MACHINE-INSTANCE
-   WALKER::ID COMMON-LISP::ARRAYP COMMON-LISP::*GENSYM-COUNTER*
-   COMMON-LISP::UPPER-CASE-P COMMON-LISP::*PRINT-CIRCLE*
-   COMMON-LISP::FTYPE COMMON-LISP::THE WALKER::WALK-LAMBDA WALKER::NAME
-   WALKER::COMPILER-LET COMMON-LISP::SET-PPRINT-DISPATCH
-   COMMON-LISP::COPY-PPRINT-DISPATCH COMMON-LISP::WRITE-TO-STRING
-   COMMON-LISP::ARRAY-TOTAL-SIZE-LIMIT WALKER::WALK-COMPILER-LET
-   COMMON-LISP::SEQUENCE COMMON-LISP::FILE-AUTHOR
-   COMMON-LISP::MULTIPLE-VALUE-CALL COMMON-LISP::*MACROEXPAND-HOOK*
-   COMMON-LISP::PLUSP COMMON-LISP::INTERNAL-TIME-UNITS-PER-SECOND
-   COMMON-LISP::LIST* COMMON-LISP::*PRINT-ARRAY*
-   COMMON-LISP::FILE-WRITE-DATE COMMON-LISP::LAMBDA COMMON-LISP::ED
-   WALKER::BLOCKED-PROG COMMON-LISP::OPEN COMMON-LISP::AREF
-   COMMON-LISP::CALL-METHOD COMMON-LISP::*PRINT-PPRINT-DISPATCH*
-   COMMON-LISP::RASSOC-IF COMMON-LISP::LOGORC1 COMMON-LISP::PROCLAIM
-   WALKER::RELIST-INTERNAL WALKER::PREDICATE COMMON-LISP::DEFMETHOD
-   COMMON-LISP::BROADCAST-STREAM-STREAMS WALKER::WALK-DECLARATIONS
-   COMMON-LISP::APPEND COMMON-LISP::CONCATENATE
-   COMMON-LISP::WRITE-STRING COMMON-LISP::MISMATCH WALKER::SUBFORM
-   WALKER::BINDINGS COMMON-LISP::SIMPLE-STRING-P COMMON-LISP::PRINT
-   COMMON-LISP::MULTIPLE-VALUES-LIMIT COMMON-LISP::PRIN1-TO-STRING
-   COMMON-LISP::PRINC-TO-STRING COMMON-LISP::FIND-METHOD
-   COMMON-LISP::SIMPLE-CONDITION COMMON-LISP::TERPRI
-   COMMON-LISP::CDAADR COMMON-LISP::FLOATING-POINT-OVERFLOW
-   COMMON-LISP::FLOATING-POINT-UNDERFLOW
-   COMMON-LISP::CALL-ARGUMENTS-LIMIT COMMON-LISP::COPY-SEQ
-   COMMON-LISP::FUNCALL
-   WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
-   COMMON-LISP::CLRHASH COMMON-LISP::SHORT-SITE-NAME
-   COMMON-LISP::LOAD-TIME-VALUE COMMON-LISP::LONG-FLOAT-EPSILON
-   COMMON-LISP::LONG-FLOAT-NEGATIVE-EPSILON COMMON-LISP::ASSOC-IF-NOT
-   COMMON-LISP::MAKE-METHOD COMMON-LISP::CAAADR
-   COMMON-LISP::SLOT-MAKUNBOUND WALKER::WALK-TAGBODY WALKER::MVB
-   COMMON-LISP::LOGANDC1 COMMON-LISP::WITH-PACKAGE-ITERATOR
-   COMMON-LISP::SLOT-BOUNDP COMMON-LISP::NUMBERP COMMON-LISP::COMPLEX
-   WALKER::TEMPLATE COMMON-LISP::INVOKE-RESTART-INTERACTIVELY
-   COMMON-LISP::IGNORE-ERRORS COMMON-LISP::AND COMMON-LISP::EVAL-WHEN
-   COMMON-LISP::LOOP COMMON-LISP::READ-FROM-STRING
-   COMMON-LISP::*STANDARD-OUTPUT* COMMON-LISP::CHAR-NAME
-   COMMON-LISP::COMPILE-FILE COMMON-LISP::FLOAT
-   COMMON-LISP::*ERROR-OUTPUT* WALKER::WALK-SETQ
-   WALKER::WITH-NEW-DEFINITION-IN-ENVIRONMENT COMMON-LISP::TYPE-ERROR
-   COMMON-LISP::PPRINT-TABULAR COMMON-LISP::COMPILATION-SPEED
-   COMMON-LISP::LOGXOR COMMON-LISP::LIST-LENGTH COMMON-LISP::DRIBBLE
-   COMMON-LISP::EXTENDED-CHAR COMMON-LISP::MAP COMMON-LISP::WITH-SLOTS
-   WALKER::EFFECT COMMON-LISP::ARRAY-ELEMENT-TYPE
-   COMMON-LISP::FDEFINITION COMMON-LISP::ROUND
-   COMMON-LISP::STRING-LEFT-TRIM COMMON-LISP::DECLAIM COMMON-LISP::SIN
-   COMMON-LISP::*PRINT-LENGTH* COMMON-LISP::DECLARATION
-   COMMON-LISP::STORE-VALUE COMMON-LISP::INTERACTIVE-STREAM-P
-   COMMON-LISP::DECODE-FLOAT COMMON-LISP::PATHNAME-NAME
-   COMMON-LISP::STRING= WALKER::WALK-LET WALKER::WALKED
-   COMMON-LISP::PHASE COMMON-LISP::DEFINE-METHOD-COMBINATION
-   WALKER::OUTER-RESULT WALKER::VALS COMMON-LISP::RASSOC
-   COMMON-LISP::LISP-IMPLEMENTATION-TYPE COMMON-LISP::UNTRACE
-   COMMON-LISP::PRINT-NOT-READABLE COMMON-LISP::ARRAY-ROW-MAJOR-INDEX
-   COMMON-LISP::DEFINE-SETF-EXPANDER COMMON-LISP::SUBSTITUTE-IF
-   WALKER::BINDING COMMON-LISP::BOOLE COMMON-LISP::TRUENAME
-   COMMON-LISP::DEFCONSTANT COMMON-LISP::OPEN-STREAM-P
-   COMMON-LISP::VALUES-LIST COMMON-LISP::&REST
-   COMMON-LISP::MAKE-RANDOM-STATE COMMON-LISP::CHAR>
-   COMMON-LISP::BYTE-SIZE COMMON-LISP::MIN COMMON-LISP::CDDDR
-   COMMON-LISP::BIT-IOR COMMON-LISP::WITH-STANDARD-IO-SYNTAX
-   COMMON-LISP::VECTOR COMMON-LISP::INVOKE-RESTART
-   COMMON-LISP::UNSIGNED-BYTE WALKER::WALK-LET/LET*
-   COMMON-LISP::SERIOUS-CONDITION COMMON-LISP::SYMBOL-PLIST
-   WALKER::MACROLET/FLET/LABELS-FORM COMMON-LISP::*READTABLE*
-   COMMON-LISP::SIMPLE-BIT-VECTOR-P
-   COMMON-LISP::LEAST-POSITIVE-SHORT-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-SINGLE-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-DOUBLE-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-LONG-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
-   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT
-   COMMON-LISP::LOWER-CASE-P COMMON-LISP::EQUALP
-   COMMON-LISP::SUBSTITUTE COMMON-LISP::SUBSEQ COMMON-LISP::MINUSP
-   COMMON-LISP::SIMPLE-CONDITION-FORMAT-CONTROL
-   COMMON-LISP::MOST-NEGATIVE-SHORT-FLOAT
-   COMMON-LISP::MOST-NEGATIVE-SINGLE-FLOAT
-   COMMON-LISP::MOST-NEGATIVE-DOUBLE-FLOAT
-   COMMON-LISP::MOST-NEGATIVE-LONG-FLOAT COMMON-LISP::FILE-LENGTH
-   COMMON-LISP::FILE-ERROR COMMON-LISP::HASH-TABLE
-   WALKER::NOTE-DECLARATION COMMON-LISP::SPEED
-   COMMON-LISP::*PRINT-RADIX* COMMON-LISP::ECHO-STREAM-INPUT-STREAM
-   COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM COMMON-LISP::UNBOUND-VARIABLE
-   COMMON-LISP::RATIONAL COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE
-   COMMON-LISP::FRESH-LINE WALKER::WALKED-ARGLIST COMMON-LISP::WHEN
-   COMMON-LISP::COMPILE COMMON-LISP::HASH-TABLE-REHASH-SIZE
-   COMMON-LISP::FLET COMMON-LISP::SPECIAL COMMON-LISP::CLASS
-   WALKER::WALK-MULTIPLE-VALUE-BIND COMMON-LISP::CELL-ERROR
-   COMMON-LISP::RPLACD COMMON-LISP::TYPE-OF
-   COMMON-LISP::SPECIAL-OPERATOR-P COMMON-LISP::PATHNAME-MATCH-P
-   WALKER::ENV-LOCK COMMON-LISP::DESCRIBE COMMON-LISP::POSITION
-   COMMON-LISP::STABLE-SORT COMMON-LISP::BOTH-CASE-P
-   COMMON-LISP::SYMBOLP COMMON-LISP::*PRINT-READABLY* WALKER::WHOLE
-   COMMON-LISP::SHADOW COMMON-LISP::STREAM COMMON-LISP::MAKE-ARRAY
-   COMMON-LISP::FUNCTIONP WALKER::CONTEXT COMMON-LISP::&WHOLE
-   COMMON-LISP::SUBST COMMON-LISP::SCHAR COMMON-LISP::ARRAY-DIMENSION
-   WALKER::LEXICAL-VARIABLES COMMON-LISP::COND
-   COMMON-LISP::DO-EXTERNAL-SYMBOLS COMMON-LISP::CHAR-CODE-LIMIT
-   COMMON-LISP::SATISFIES COMMON-LISP::MASK-FIELD
-   COMMON-LISP::ARITHMETIC-ERROR WALKER::WALK-LET* COMMON-LISP::CADDR
-   COMMON-LISP::LAMBDA-LIST-KEYWORDS COMMON-LISP::STRING-NOT-EQUAL
-   COMMON-LISP::CONTINUE COMMON-LISP::STRING-LESSP
-   COMMON-LISP::USE-PACKAGE COMMON-LISP::MULTIPLE-VALUE-SETQ
-   WALKER::WALKER-ENVIRONMENT-BIND-1 WALKER::ARM2 COMMON-LISP::>=
-   COMMON-LISP::LOGEQV COMMON-LISP::HASH-TABLE-P
-   COMMON-LISP::GRAPHIC-CHAR-P COMMON-LISP::PRINT-UNREADABLE-OBJECT
-   COMMON-LISP::EQL COMMON-LISP::MAPHASH COMMON-LISP::NINTERSECTION
-   COMMON-LISP::<= WALKER::WFOP COMMON-LISP::NAMESTRING
-   COMMON-LISP::MAKE-CONCATENATED-STREAM COMMON-LISP::MAKE-INSTANCE
-   COMMON-LISP::SHORT-FLOAT COMMON-LISP::FILE-STREAM
-   COMMON-LISP::WRITE-LINE COMMON-LISP::VECTOR-PUSH COMMON-LISP::ENDP
-   WALKER::WALK-TAGBODY-1 WALKER::WALK-FUNCTION WALKER::REPEAT
-   COMMON-LISP::DIRECTORY COMMON-LISP::TYPE COMMON-LISP::ASSOC-IF
-   COMMON-LISP::DPB COMMON-LISP::TYPEP COMMON-LISP::FIFTH
-   WALKER::GET-WALKER-TEMPLATE-INTERNAL COMMON-LISP::LOGNAND
-   COMMON-LISP::SIGNED-BYTE COMMON-LISP::EVERY WALKER::DECLARATIONS
-   WALKER::SYMMAC COMMON-LISP::PPRINT-POP COMMON-LISP::SUBLIS
-   COMMON-LISP::NULL COMMON-LISP::FLOATP COMMON-LISP::STRING<
-   COMMON-LISP::*TRACE-OUTPUT* WALKER::CONVERT-MACRO-TO-LAMBDA
-   COMMON-LISP::WRITE-CHAR COMMON-LISP::*DEBUGGER-HOOK*
-   COMMON-LISP::*PRINT-RIGHT-MARGIN*
-   COMMON-LISP::STANDARD-GENERIC-FUNCTION COMMON-LISP::MAPL
-   COMMON-LISP::PROG1 COMMON-LISP::COMPLEXP COMMON-LISP::INSPECT
-   COMMON-LISP::MACROEXPAND-1 COMMON-LISP::BIT-ANDC1 COMMON-LISP::SETQ
-   COMMON-LISP::CHAR>= COMMON-LISP::READTABLE-CASE
-   COMMON-LISP::REALPART COMMON-LISP::LDIFF COMMON-LISP::SINH
-   COMMON-LISP::BROADCAST-STREAM COMMON-LISP::MAKE-STRING
-   COMMON-LISP::BASE-STRING WALKER::SETS COMMON-LISP::CDDDAR
-   COMMON-LISP::INTEGER-LENGTH COMMON-LISP::OUTPUT-STREAM-P
-   COMMON-LISP::NUNION COMMON-LISP::/= COMMON-LISP::SLOT-MISSING
-   COMMON-LISP::PACKAGE-NAME COMMON-LISP::ECASE
-   COMMON-LISP::INVOKE-DEBUGGER COMMON-LISP::PATHNAME
-   COMMON-LISP::APPLY COMMON-LISP::CHAR-INT COMMON-LISP::TAN
-   COMMON-LISP::MOST-NEGATIVE-FIXNUM COMMON-LISP::MAKE-SYNONYM-STREAM
-   WALKER::WALK-BINDINGS-2 WALKER::WALK-LABELS WALKER::ENV
-   COMMON-LISP::MACROEXPAND COMMON-LISP::CADDAR COMMON-LISP::ISQRT
-   COMMON-LISP::CCASE COMMON-LISP::COMPUTE-APPLICABLE-METHODS
-   COMMON-LISP::GCD WALKER::WALK-FORM-INTERNAL WALKER::LEXICALS
-   WALKER::DESTRUCTURINGP COMMON-LISP::KEYWORD COMMON-LISP::UNLESS
-   COMMON-LISP::MAP-INTO COMMON-LISP::*LOAD-TRUENAME*
-   COMMON-LISP::SIMPLE-ERROR COMMON-LISP::SYNONYM-STREAM
-   WALKER::WALK-FLET COMMON-LISP::SUBSETP COMMON-LISP::POSITION-IF
-   COMMON-LISP::INCF WALKER::NEW-ENV WALKER::REPEAT-TEMPLATE
-   COMMON-LISP::SHIFTF COMMON-LISP::BOOLE-XOR COMMON-LISP::REM
-   COMMON-LISP::LOGNOR WALKER::WALK-TEMPLATE
-   WALKER::NOTE-LEXICAL-BINDING WALKER::FORM WALKER::ENVIRONMENT
-   COMMON-LISP::FIND COMMON-LISP::MAX COMMON-LISP::GET-SETF-EXPANSION
-   COMMON-LISP::PPRINT-DISPATCH COMMON-LISP::SIMPLE-VECTOR-P
-   COMMON-LISP::SLOT-EXISTS-P COMMON-LISP::IMPORT
-   COMMON-LISP::MACHINE-VERSION COMMON-LISP::SHADOWING-IMPORT
-   COMMON-LISP::BOOLE-EQV COMMON-LISP::CONJUGATE
-   COMMON-LISP::READ-CHAR-NO-HANG COMMON-LISP::WRITE-BYTE
-   COMMON-LISP::WITH-OUTPUT-TO-STRING COMMON-LISP::BYTE-POSITION
-   COMMON-LISP::STANDARD-CHAR COMMON-LISP::STRING
-   COMMON-LISP::MEMBER-IF WALKER::WFNP WALKER::X
-   COMMON-LISP::NSTRING-UPCASE COMMON-LISP::DEFMACRO
-   COMMON-LISP::BUTLAST COMMON-LISP::NEXT-METHOD-P COMMON-LISP::CDDAAR
-   COMMON-LISP::RESTART-BIND COMMON-LISP::IMAGPART
-   COMMON-LISP::LOGANDC2 COMMON-LISP::HASH-TABLE-SIZE
-   COMMON-LISP::*COMPILE-VERBOSE* COMMON-LISP::FFLOOR
-   COMMON-LISP::INVALID-METHOD-ERROR COMMON-LISP::DEFGENERIC
-   COMMON-LISP::*PRINT-LEVEL* COMMON-LISP::DEFSTRUCT
-   COMMON-LISP::DELETE-PACKAGE COMMON-LISP::BOOLE-CLR
-   COMMON-LISP::DO-SYMBOLS COMMON-LISP::INTEGERP COMMON-LISP::NUMBER
-   COMMON-LISP::CADAAR COMMON-LISP::NIL COMMON-LISP::T
-   WALKER::*KEY-TO-WALKER-ENVIRONMENT* COMMON-LISP::DELETE
-   COMMON-LISP::DEFINE-MODIFY-MACRO
-   COMMON-LISP::ENSURE-GENERIC-FUNCTION COMMON-LISP::COMPILED-FUNCTION
-   COMMON-LISP::NOTEVERY COMMON-LISP::BOOLE-2 COMMON-LISP::STRUCTURE
-   COMMON-LISP::PPRINT-LINEAR COMMON-LISP::FIND-RESTART
-   COMMON-LISP::UNBOUND-SLOT COMMON-LISP::RENAME-PACKAGE
-   COMMON-LISP::SIGNUM COMMON-LISP::CDDDDR WALKER::LAMBDA-BLOCK
-   COMMON-LISP::FILE-POSITION COMMON-LISP::LOGBITP
-   COMMON-LISP::STANDARD-METHOD COMMON-LISP::PSETQ
-   COMMON-LISP::SIMPLE-CONDITION-FORMAT-ARGUMENTS COMMON-LISP::EVAL
-   COMMON-LISP::CHAR-GREATERP COMMON-LISP::CERROR
-   COMMON-LISP::UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
-   COMMON-LISP::UPDATE-INSTANCE-FOR-REDEFINED-CLASS
-   COMMON-LISP::SYMBOL-VALUE COMMON-LISP::+++ WALKER::M
-   COMMON-LISP::LCM COMMON-LISP::BOOLE-NAND COMMON-LISP::SIMPLE-ARRAY
-   COMMON-LISP::CADDDR COMMON-LISP::SIMPLE-BIT-VECTOR
-   COMMON-LISP::PRIN1 COMMON-LISP::BIT-ORC1
-   COMMON-LISP::*LOAD-PATHNAME* WALKER::WALK-SYMBOL-MACROLET
-   WALKER::ARGS COMMON-LISP::STREAM-ERROR-STREAM COMMON-LISP::PSETF
-   COMMON-LISP::RETURN COMMON-LISP::MAKE-PATHNAME
-   COMMON-LISP::TYPE-ERROR-EXPECTED-TYPE
-   COMMON-LISP::FILE-STRING-LENGTH COMMON-LISP::DOTIMES
-   COMMON-LISP::DEPOSIT-FIELD COMMON-LISP::*QUERY-IO*
-   COMMON-LISP::MAKE-CONDITION COMMON-LISP::&ENVIRONMENT
-   COMMON-LISP::ARRAY-DIMENSIONS COMMON-LISP::MAKE-BROADCAST-STREAM
-   COMMON-LISP::BOOLE-ANDC2 COMMON-LISP::MAKE-TWO-WAY-STREAM
-   COMMON-LISP::INPUT-STREAM-P WALKER::ARGLIST
-   COMMON-LISP::DIGIT-CHAR-P WALKER::LEXP COMMON-LISP::*STANDARD-INPUT*
-   COMMON-LISP::BOUNDP COMMON-LISP::ODDP
-   COMMON-LISP::READ-DELIMITED-LIST WALKER::F
-   COMMON-LISP::ARITHMETIC-ERROR-OPERANDS COMMON-LISP::SIXTH
-   WALKER::MAC WALKER::E COMMON-LISP::SUBTYPEP
-   COMMON-LISP::NSTRING-CAPITALIZE COMMON-LISP::DECLARE
-   COMMON-LISP::FLOOR WALKER::STOP-FORM COMMON-LISP::GENSYM
-   COMMON-LISP::ARRAY-HAS-FILL-POINTER-P COMMON-LISP::LOGIOR WALKER::C
-   COMMON-LISP::Y-OR-N-P COMMON-LISP::PARSE-NAMESTRING
-   COMMON-LISP::ARRAY-RANK COMMON-LISP::NINTH
-   COMMON-LISP::WITH-INPUT-FROM-STRING COMMON-LISP::INTEGER
-   COMMON-LISP::MAKE-SEQUENCE COMMON-LISP::SET-EXCLUSIVE-OR
-   COMMON-LISP::CHAR< COMMON-LISP::INLINE COMMON-LISP::CDDADR
-   COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::TANH COMMON-LISP::ATAN
-   COMMON-LISP::NOT COMMON-LISP::LONG-SITE-NAME
-   COMMON-LISP::PATHNAME-VERSION COMMON-LISP::MAPCAN
-   COMMON-LISP::REQUIRE WALKER::WALK-NO-MORE-P COMMON-LISP::RPLACA
-   COMMON-LISP::TAGBODY COMMON-LISP::COPY-ALIST COMMON-LISP::CADADR
-   COMMON-LISP::MAPCAR COMMON-LISP::RESTART-NAME COMMON-LISP::>
-   WALKER::WALK-REPEAT-EVAL COMMON-LISP::FIND-PACKAGE
-   COMMON-LISP::FBOUNDP COMMON-LISP::DEFINE-SYMBOL-MACRO COMMON-LISP::=
-   WALKER::WALK-PROG WALKER::WALK-PROG* COMMON-LISP::DEFSETF
-   COMMON-LISP::ZEROP COMMON-LISP::UNUSE-PACKAGE
-   COMMON-LISP::MOST-POSITIVE-SHORT-FLOAT
-   COMMON-LISP::MOST-POSITIVE-SINGLE-FLOAT
-   COMMON-LISP::MOST-POSITIVE-DOUBLE-FLOAT
-   COMMON-LISP::MOST-POSITIVE-LONG-FLOAT COMMON-LISP::LOGICAL-PATHNAME
-   COMMON-LISP::< WALKER::WALK-ARGLIST COMMON-LISP::LOGCOUNT
-   COMMON-LISP::ENOUGH-NAMESTRING COMMON-LISP::MULTIPLE-VALUE-LIST
-   COMMON-LISP::TWO-WAY-STREAM COMMON-LISP::CDDR COMMON-LISP::ASSOC
-   COMMON-LISP::REMF COMMON-LISP::LDB COMMON-LISP::MACROLET
-   COMMON-LISP::CDADR WALKER::WALK-DO COMMON-LISP::UNION
-   COMMON-LISP::FIND-ALL-SYMBOLS COMMON-LISP::MAKE-PACKAGE
-   WALKER::WALK-LOCALLY COMMON-LISP::&OPTIONAL
-   COMMON-LISP::COPY-STRUCTURE COMMON-LISP::THIRD COMMON-LISP::LABELS
-   COMMON-LISP::BOOLE-C1 COMMON-LISP::PPRINT-INDENT
-   WALKER::WALK-MACROLET WALKER::TEMP COMMON-LISP::FIND-IF-NOT
-   COMMON-LISP::FORMATTER COMMON-LISP::HANDLER-CASE WALKER::NEWNEWFORM
-   WALKER::REAL-ENV COMMON-LISP::LOAD COMMON-LISP::DELETE-IF-NOT
-   COMMON-LISP::ACONS COMMON-LISP::UNDEFINED-FUNCTION
-   COMMON-LISP::WILD-PATHNAME-P COMMON-LISP::PACKAGEP
-   COMMON-LISP::ENCODE-UNIVERSAL-TIME WALKER::VAL COMMON-LISP::FORMAT
-   COMMON-LISP::TENTH COMMON-LISP::STRUCTURE-CLASS
-   COMMON-LISP::MEMBER-IF-NOT COMMON-LISP::LEAST-NEGATIVE-SHORT-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-SINGLE-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-LONG-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
-   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT
-   WALKER::WALK-MULTIPLE-VALUE-SETQ WALKER::GET-WALKER-TEMPLATE
-   COMMON-LISP::BOOLE-1 COMMON-LISP::REDUCE WALKER::WALK-NAMED-LAMBDA
-   WALKER::WALKED-BODY COMMON-LISP::SVREF
-   COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::NTH-VALUE
-   COMMON-LISP::FORCE-OUTPUT COMMON-LISP::NSUBSTITUTE-IF-NOT
-   COMMON-LISP::CATCH COMMON-LISP::STORAGE-CONDITION
-   COMMON-LISP::USE-VALUE COMMON-LISP::MERGE COMMON-LISP::CASE
-   COMMON-LISP::CLEAR-INPUT COMMON-LISP::MUFFLE-WARNING
-   COMMON-LISP::REPLACE COMMON-LISP::*** COMMON-LISP::GENERIC-FUNCTION
-   COMMON-LISP::/ COMMON-LISP::BOOLE-SET COMMON-LISP::SOFTWARE-VERSION
-   COMMON-LISP::APROPOS-LIST COMMON-LISP::POSITION-IF-NOT
-   COMMON-LISP::READ-BYTE COMMON-LISP::FLOAT-RADIX
-   WALKER::ENVIRONMENT-MACRO COMMON-LISP::DECF COMMON-LISP::PROG
-   COMMON-LISP::CALL-NEXT-METHOD COMMON-LISP::- WALKER::OLD-BODY
-   COMMON-LISP::MAPCON COMMON-LISP::CELL-ERROR-NAME
-   WALKER::WALKED-BINDING COMMON-LISP::INITIALIZE-INSTANCE
-   COMMON-LISP::CADR COMMON-LISP::EQUAL COMMON-LISP::CAADR
-   COMMON-LISP::MAKE-LOAD-FORM COMMON-LISP::WITH-SIMPLE-RESTART
-   COMMON-LISP::+ WALKER::DECL COMMON-LISP::PATHNAME-DEVICE
-   COMMON-LISP::MACRO-FUNCTION COMMON-LISP::MAPLIST
-   COMMON-LISP::REVERSE COMMON-LISP::FIND-SYMBOL COMMON-LISP::*
-   COMMON-LISP::LOCALLY COMMON-LISP::BIT-ANDC2 COMMON-LISP::*FEATURES*
-   COMMON-LISP::DIVISION-BY-ZERO COMMON-LISP::ARRAY WALKER::DECP
-   COMMON-LISP::DEFPARAMETER COMMON-LISP::PATHNAME-DIRECTORY
-   COMMON-LISP::WITH-CONDITION-RESTARTS COMMON-LISP::STRING-NOT-LESSP
-   COMMON-LISP::ELT COMMON-LISP::NTH COMMON-LISP::RETURN-FROM
-   COMMON-LISP::COMPILER-MACRO COMMON-LISP::BIGNUM
-   COMMON-LISP::PACKAGE-ERROR-PACKAGE COMMON-LISP::MAKE-SYMBOL
-   COMMON-LISP::WITH-COMPILATION-UNIT COMMON-LISP::FILL
-   COMMON-LISP::CHAR-CODE WALKER::LET/LET* COMMON-LISP::*PRINT-ESCAPE*
-   COMMON-LISP::*PRINT-BASE* COMMON-LISP::*PRINT-CASE*
-   COMMON-LISP::FLOATING-POINT-INVALID-OPERATION COMMON-LISP::NSUBST
-   COMMON-LISP::SIMPLE-VECTOR COMMON-LISP::ARRAY-IN-BOUNDS-P
-   COMMON-LISP::READ-PRESERVING-WHITESPACE COMMON-LISP::ATANH
-   COMMON-LISP::ATOM COMMON-LISP::BIT-NAND WALKER::THING
-   COMMON-LISP::RESTART COMMON-LISP::VECTOR-POP COMMON-LISP::MEMBER
-   WALKER::VARS COMMON-LISP::REMOVE COMMON-LISP::PPRINT-TAB
-   COMMON-LISP::CHAR<= COMMON-LISP::PUSH COMMON-LISP::PROGRAM-ERROR
-   WALKER::TEMPS COMMON-LISP::CHAR-UPCASE COMMON-LISP::*PRINT-PRETTY*
-   COMMON-LISP::MOST-POSITIVE-FIXNUM COMMON-LISP::PATHNAME-HOST
-   COMMON-LISP::DOCUMENTATION COMMON-LISP:://
-   COMMON-LISP::SHARED-INITIALIZE COMMON-LISP::UNEXPORT
-   COMMON-LISP::PROBE-FILE COMMON-LISP::STANDARD-CLASS
-   COMMON-LISP::GET-INTERNAL-RUN-TIME
-   COMMON-LISP::GET-INTERNAL-REAL-TIME COMMON-LISP::NOTANY
-   WALKER::.LET-IF-DUMMY. COMMON-LISP::COMPILER-MACRO-FUNCTION
-   COMMON-LISP::ROOM COMMON-LISP::UNBOUND-SLOT-INSTANCE
-   COMMON-LISP::COS COMMON-LISP::CHAR-DOWNCASE COMMON-LISP::CONSTANTLY
-   COMMON-LISP::RATIONALIZE COMMON-LISP::LISP-IMPLEMENTATION-VERSION
-   COMMON-LISP::CONSTANTP COMMON-LISP::HASH-TABLE-COUNT
-   COMMON-LISP::STREAMP COMMON-LISP::NO-APPLICABLE-METHOD
-   WALKER::NEWFORM WALKER::ENV-WALK-FUNCTION COMMON-LISP::1-
-   COMMON-LISP::BIT-XOR COMMON-LISP::STRING-STREAM
-   COMMON-LISP::GET-PROPERTIES COMMON-LISP::COUNT-IF-NOT
-   COMMON-LISP::BIT COMMON-LISP::ASH COMMON-LISP::NSUBLIS
-   COMMON-LISP::PPRINT-LOGICAL-BLOCK COMMON-LISP::FIND-CLASS
-   COMMON-LISP::FOURTH COMMON-LISP::STRING<= COMMON-LISP::STRING>=
-   COMMON-LISP::STRING/= COMMON-LISP::SLEEP WALKER::MACROS
-   WALKER::MV-FORM COMMON-LISP::TREE-EQUAL
-   COMMON-LISP::DEFINE-CONDITION COMMON-LISP::SET
-   COMMON-LISP::STRING-GREATERP COMMON-LISP::SINGLE-FLOAT-EPSILON
-   COMMON-LISP::SINGLE-FLOAT-NEGATIVE-EPSILON COMMON-LISP::COMPLEMENT
-   COMMON-LISP::WRITE COMMON-LISP::NCONC
-   COMMON-LISP::DECODE-UNIVERSAL-TIME COMMON-LISP::*PRINT-MISER-WIDTH*
-   COMMON-LISP::BUILT-IN-CLASS COMMON-LISP::*RANDOM-STATE*
-   COMMON-LISP::*COMPILE-FILE-PATHNAME*
-   COMMON-LISP::*COMPILE-FILE-TRUENAME*
-   WALKER::WALK-TEMPLATE-HANDLE-REPEAT WALKER::WALKED-BINDINGS
-   WALKER::RFORMS WALKER::WALK-DEFINITIONS COMMON-LISP::BOOLE-ORC1
-   COMMON-LISP::BOOLE-ORC2 COMMON-LISP::FILE-NAMESTRING
-   COMMON-LISP::BIT-ORC2 COMMON-LISP::1+
-   COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM
-   COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM COMMON-LISP::PROG2
-   COMMON-LISP::*READ-SUPPRESS* COMMON-LISP::PPRINT-FILL
-   COMMON-LISP::DOLIST COMMON-LISP::SIMPLE-BASE-STRING
-   COMMON-LISP::SLOT-VALUE COMMON-LISP::LET
-   COMMON-LISP::CHAR-NOT-GREATERP COMMON-LISP::PATHNAMEP
-   COMMON-LISP::READ COMMON-LISP::RANDOM-STATE-P
-   COMMON-LISP::*READ-EVAL* COMMON-LISP::CDDAR COMMON-LISP::REMOVE-IF
-   COMMON-LISP::&ALLOW-OTHER-KEYS WALKER::OUTER-WALK-FUNCTION
-   COMMON-LISP::FROUND COMMON-LISP::CHAR-EQUAL
-   COMMON-LISP::MAKE-DISPATCH-MACRO-CHARACTER COMMON-LISP::EIGHTH
-   COMMON-LISP::OPTIMIZE WALKER::RECONS COMMON-LISP::++
-   COMMON-LISP::DO* COMMON-LISP::SIMPLE-TYPE-ERROR COMMON-LISP::ASIN
-   COMMON-LISP::SINGLE-FLOAT COMMON-LISP::REAL COMMON-LISP::CHARACTER
-   COMMON-LISP::CHARACTERP COMMON-LISP::GET
-   WALKER::ENV-LEXICAL-VARIABLES COMMON-LISP::REALP
-   COMMON-LISP::FCEILING COMMON-LISP::COPY-SYMBOL
-   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS COMMON-LISP::CHAR
-   WALKER::EXPANDED COMMON-LISP::STANDARD-CHAR-P
-   COMMON-LISP::*DEBUG-IO* COMMON-LISP::FIXNUM
-   COMMON-LISP::COMPILED-FUNCTION-P WALKER::WALK-UNEXPECTED-DECLARE
-   COMMON-LISP::COUNT-IF COMMON-LISP::** COMMON-LISP::COMPUTE-RESTARTS
-   COMMON-LISP::METHOD COMMON-LISP::WITH-OPEN-FILE COMMON-LISP::PACKAGE
-   COMMON-LISP::IGNORE COMMON-LISP::IDENTITY COMMON-LISP::CTYPECASE
-   COMMON-LISP::ETYPECASE COMMON-LISP::PROGV
-   COMMON-LISP::WITH-ACCESSORS COMMON-LISP::NSUBSTITUTE-IF
-   COMMON-LISP::BOOLE-NOR)
- "WALKER")
-
 ;;; Definitions for package SLOT-ACCESSOR-NAME of type SHADOW
 (COMMON-LISP::SHADOW 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
 (COMMON-LISP::SHADOWING-IMPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
@@ -1541,6 +1026,521 @@
    COMMON-LISP::NSUBSTITUTE-IF COMMON-LISP::BOOLE-NOR)
  "SLOT-ACCESSOR-NAME")
 
+;;; Definitions for package WALKER of type SHADOW
+(COMMON-LISP::SHADOW 'COMMON-LISP::NIL "WALKER")
+(COMMON-LISP::SHADOWING-IMPORT 'COMMON-LISP::NIL "WALKER")
+(COMMON-LISP::IMPORT
+ '(WALKER::DEFINE-WALKER-TEMPLATE
+   WALKER::*VARIABLE-DECLARATIONS* WALKER::NESTED-WALK-FORM
+   WALKER::VARIABLE-DECLARATION WALKER::WALK-FORM-EXPAND-MACROS-P
+   WALKER::VARIABLE-LEXICAL-P SYSTEM::MACRO WALKER::VARIABLE-SPECIAL-P
+   WALKER::WALK-FORM WALKER::MACROEXPAND-ALL
+   WALKER::VARIABLE-GLOBALLY-SPECIAL-P WALKER::DO/DO* COMMON-LISP::EXP
+   COMMON-LISP::DEFVAR COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
+   COMMON-LISP::DISASSEMBLE COMMON-LISP::DELETE-IF WALKER::REAL-BODY
+   COMMON-LISP::CONCATENATED-STREAM-STREAMS COMMON-LISP::CLASS-OF
+   WALKER::WALK-DO* WALKER::WALK-PROG/PROG* WALKER::DEFINITION
+   COMMON-LISP::NSUBST-IF-NOT COMMON-LISP::CIS COMMON-LISP::LOGAND
+   COMMON-LISP::BIT-EQV COMMON-LISP::MAKE-INSTANCES-OBSOLETE
+   COMMON-LISP::RANDOM COMMON-LISP::COPY-LIST WALKER::CALL
+   COMMON-LISP::KEYWORDP WALKER::DOC-STRING-P
+   COMMON-LISP::*BREAK-ON-SIGNALS* COMMON-LISP::CADAR
+   COMMON-LISP::MERGE-PATHNAMES COMMON-LISP::BOOLE-C2
+   COMMON-LISP::BIT-NOT COMMON-LISP::STANDARD-OBJECT
+   COMMON-LISP::STRINGP WALKER::LLIST COMMON-LISP::METHOD-COMBINATION
+   COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::CLOSE
+   COMMON-LISP::INTEGER-DECODE-FLOAT COMMON-LISP::PPRINT-NEWLINE
+   COMMON-LISP::CHAR-NOT-EQUAL WALKER::ARG WALKER::ARM1
+   COMMON-LISP::COSH COMMON-LISP::NTHCDR
+   COMMON-LISP::GET-UNIVERSAL-TIME COMMON-LISP::YES-OR-NO-P
+   WALKER::END-TEST COMMON-LISP::READ-LINE COMMON-LISP::LET*
+   WALKER::WALKER-ENVIRONMENT-BIND WALKER::OLD-ENV
+   COMMON-LISP::PATHNAME-TYPE COMMON-LISP::FLOAT-PRECISION
+   COMMON-LISP::PROG* WALKER::ENVIRONMENT-FUNCTION
+   COMMON-LISP::SYMBOL-NAME COMMON-LISP::LOG COMMON-LISP::OR
+   COMMON-LISP::PACKAGE-SHADOWING-SYMBOLS COMMON-LISP::BREAK
+   COMMON-LISP::STRUCTURE-OBJECT COMMON-LISP::ROTATEF COMMON-LISP::SQRT
+   COMMON-LISP::CONS COMMON-LISP::NSUBST-IF WALKER::POSSIBLE-BLOCK-NAME
+   COMMON-LISP::UNWIND-PROTECT COMMON-LISP::CONSP
+   COMMON-LISP::FLOAT-SIGN COMMON-LISP::SOME COMMON-LISP::MAPC
+   WALKER::BODY COMMON-LISP::SETF COMMON-LISP::CEILING
+   COMMON-LISP::&BODY COMMON-LISP::CDAR COMMON-LISP::STANDARD
+   COMMON-LISP::MAKE-LIST COMMON-LISP::MAKE-HASH-TABLE
+   COMMON-LISP::STRING-UPCASE COMMON-LISP::STRING-DOWNCASE
+   COMMON-LISP::STYLE-WARNING COMMON-LISP::ASINH COMMON-LISP::DEFCLASS
+   COMMON-LISP::NRECONC COMMON-LISP::NSTRING-DOWNCASE
+   COMMON-LISP::SECOND WALKER::ENV-DECLARATIONS WALKER::SEQUENTIALP
+   COMMON-LISP::RATIONALP COMMON-LISP::SET-DISPATCH-MACRO-CHARACTER
+   COMMON-LISP::GET-DISPATCH-MACRO-CHARACTER COMMON-LISP::CHECK-TYPE
+   COMMON-LISP::MAKE-STRING-INPUT-STREAM
+   COMMON-LISP::MAKE-STRING-OUTPUT-STREAM
+   WALKER::VARIABLE-SYMBOL-MACRO-P COMMON-LISP::SAFETY
+   COMMON-LISP::*READ-DEFAULT-FLOAT-FORMAT* COMMON-LISP::*LOAD-VERBOSE*
+   COMMON-LISP::OTHERWISE COMMON-LISP::NBUTLAST COMMON-LISP::ADD-METHOD
+   COMMON-LISP::PPRINT-EXIT-IF-LIST-EXHAUSTED COMMON-LISP::SORT
+   COMMON-LISP::WARNING WALKER::LOCK COMMON-LISP::DEFINE-COMPILER-MACRO
+   COMMON-LISP::PROGN COMMON-LISP::PUSHNEW WALKER::WALK-LET-IF
+   COMMON-LISP::CHAR= COMMON-LISP::MAKE-ECHO-STREAM
+   COMMON-LISP::BIT-AND WALKER::UNBOUND-LEXICAL-FUNCTION
+   COMMON-LISP::EXPORT WALKER::WALKER-TEMPLATE COMMON-LISP::EQ
+   COMMON-LISP::SOFTWARE-TYPE COMMON-LISP::LOGTEST
+   COMMON-LISP::LIST-ALL-PACKAGES COMMON-LISP::DEFTYPE
+   COMMON-LISP::GETF COMMON-LISP::ROW-MAJOR-AREF COMMON-LISP::TYPECASE
+   WALKER::EXPANSION COMMON-LISP::HASH-TABLE-TEST
+   COMMON-LISP::USER-HOMEDIR-PATHNAME COMMON-LISP::SYMBOL-PACKAGE
+   COMMON-LISP::BOOLEAN COMMON-LISP::HOST-NAMESTRING
+   COMMON-LISP::IN-PACKAGE COMMON-LISP::CAAR COMMON-LISP::INTERN
+   COMMON-LISP::CONDITION COMMON-LISP::LOGNOT COMMON-LISP::SUBST-IF-NOT
+   COMMON-LISP::COPY-READTABLE COMMON-LISP::REVAPPEND
+   COMMON-LISP::SYMBOL WALKER::REMOTE COMMON-LISP::BIT-VECTOR
+   COMMON-LISP::SEARCH WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
+   WALKER::INNER-NO-MORE-P COMMON-LISP::STREAM-ELEMENT-TYPE
+   COMMON-LISP::POP COMMON-LISP::SLOT-UNBOUND COMMON-LISP::GO
+   COMMON-LISP::LIST COMMON-LISP::*LOAD-PRINT* WALKER::MACRO-ENV
+   COMMON-LISP::SET-MACRO-CHARACTER COMMON-LISP::GET-MACRO-CHARACTER
+   COMMON-LISP::PARSE-ERROR COMMON-LISP::FILE-ERROR-PATHNAME
+   COMMON-LISP::CHANGE-CLASS COMMON-LISP::VALUES
+   COMMON-LISP::DESTRUCTURING-BIND COMMON-LISP::RANDOM-STATE
+   COMMON-LISP::LISTP COMMON-LISP::UPGRADED-COMPLEX-PART-TYPE
+   COMMON-LISP::CHAR/= WALKER::WALK-BINDINGS-1 COMMON-LISP::REMPROP
+   COMMON-LISP::DO COMMON-LISP::SYMBOL-MACROLET COMMON-LISP::ABS
+   COMMON-LISP::&KEY COMMON-LISP::VECTOR-PUSH-EXTEND
+   COMMON-LISP::DEFPACKAGE COMMON-LISP::PACKAGE-NICKNAMES
+   COMMON-LISP::MULTIPLE-VALUE-PROG1 WALKER::FN
+   COMMON-LISP::SYNONYM-STREAM-SYMBOL COMMON-LISP::RESTART-CASE
+   COMMON-LISP::END-OF-FILE COMMON-LISP::*DEFAULT-PATHNAME-DEFAULTS*
+   COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS COMMON-LISP::EXPT
+   WALKER::WALK-IF WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 WALKER::MACROP
+   COMMON-LISP::READER-ERROR COMMON-LISP::ABORT COMMON-LISP::CLASS-NAME
+   COMMON-LISP::REMHASH COMMON-LISP::BLOCK COMMON-LISP::PACKAGE-ERROR
+   COMMON-LISP::SIGNAL COMMON-LISP::PARSE-INTEGER COMMON-LISP::TIME
+   COMMON-LISP::COERCE COMMON-LISP::FIND-IF COMMON-LISP::UNREAD-CHAR
+   WALKER::WALK-DO/DO* COMMON-LISP::DOUBLE-FLOAT-EPSILON
+   COMMON-LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON COMMON-LISP::BOOLE-IOR
+   COMMON-LISP::ASSERT COMMON-LISP::ADJUSTABLE-ARRAY-P WALKER::TEST
+   COMMON-LISP::COPY-TREE COMMON-LISP::*PRINT-LINES* COMMON-LISP::DEBUG
+   WALKER::VAR COMMON-LISP::CLEAR-OUTPUT COMMON-LISP::CODE-CHAR
+   COMMON-LISP::STRING-CAPITALIZE COMMON-LISP::///
+   COMMON-LISP::WITH-OPEN-STREAM WALKER::WITH-AUGMENTED-ENVIRONMENT
+   COMMON-LISP::REST COMMON-LISP::ACOS COMMON-LISP::MACHINE-TYPE
+   WALKER::RELIST WALKER::DEFINITIONS COMMON-LISP::DENOMINATOR
+   COMMON-LISP::TRACE COMMON-LISP::PRINT-NOT-READABLE-OBJECT
+   COMMON-LISP::FLOATING-POINT-INEXACT COMMON-LISP::*READ-BASE*
+   COMMON-LISP::ENSURE-DIRECTORIES-EXIST COMMON-LISP::CDR
+   COMMON-LISP::STRING-EQUAL COMMON-LISP::HASH-TABLE-REHASH-THRESHOLD
+   WALKER::NEW-FORM COMMON-LISP::DELETE-FILE COMMON-LISP::FIRST
+   COMMON-LISP::ALPHANUMERICP COMMON-LISP::WITH-HASH-TABLE-ITERATOR
+   COMMON-LISP::SCALE-FLOAT COMMON-LISP::CONCATENATED-STREAM
+   COMMON-LISP::CONTROL-ERROR COMMON-LISP::FINISH-OUTPUT
+   COMMON-LISP::LAMBDA-PARAMETERS-LIMIT COMMON-LISP::PRINC
+   COMMON-LISP::ADJOIN COMMON-LISP::PI
+   COMMON-LISP::ARITHMETIC-ERROR-OPERATION COMMON-LISP::DOUBLE-FLOAT
+   COMMON-LISP::READTABLE COMMON-LISP::READTABLEP
+   COMMON-LISP::READ-SEQUENCE COMMON-LISP::FUNCTION-LAMBDA-EXPRESSION
+   COMMON-LISP::ARRAY-RANK-LIMIT COMMON-LISP::WRITE-SEQUENCE
+   WALKER::ENTRY COMMON-LISP::RENAME-FILE COMMON-LISP::READ-CHAR
+   COMMON-LISP::PEEK-CHAR COMMON-LISP::REMOVE-DUPLICATES
+   COMMON-LISP::BYTE COMMON-LISP::*MODULES*
+   COMMON-LISP::GET-OUTPUT-STREAM-STRING WALKER::*P
+   COMMON-LISP::DYNAMIC-EXTENT COMMON-LISP::LOOP-FINISH
+   COMMON-LISP::MULTIPLE-VALUE-BIND COMMON-LISP::VECTORP
+   COMMON-LISP::RASSOC-IF-NOT COMMON-LISP::UNINTERN COMMON-LISP::CDADAR
+   COMMON-LISP::FUNCTION WALKER::OUTER-NO-MORE-P COMMON-LISP::LOGORC2
+   COMMON-LISP::*PACKAGE* COMMON-LISP::STRING-NOT-GREATERP
+   COMMON-LISP::INTERSECTION WALKER::TAIL COMMON-LISP::SPACE
+   COMMON-LISP::SEVENTH COMMON-LISP::BASE-CHAR COMMON-LISP::NAME-CHAR
+   COMMON-LISP::SBIT COMMON-LISP::CAADAR COMMON-LISP::TAILP
+   COMMON-LISP::*TERMINAL-IO* COMMON-LISP::STREAM-ERROR
+   COMMON-LISP::BOOLE-ANDC1 COMMON-LISP::DO-ALL-SYMBOLS
+   COMMON-LISP::IGNORABLE COMMON-LISP::MAKUNBOUND COMMON-LISP::PROVIDE
+   COMMON-LISP::THROW COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS
+   COMMON-LISP::LENGTH COMMON-LISP::CDAAR COMMON-LISP::&AUX
+   COMMON-LISP::ARRAY-DISPLACEMENT COMMON-LISP::HANDLER-BIND
+   COMMON-LISP::PAIRLIS WALKER::FUNCTIONS COMMON-LISP::*PRINT-GENSYM*
+   COMMON-LISP::COMPILE-FILE-PATHNAME COMMON-LISP::CAR
+   COMMON-LISP::FTRUNCATE COMMON-LISP::DELETE-DUPLICATES
+   COMMON-LISP::NREVERSE COMMON-LISP::APROPOS
+   COMMON-LISP::STRING-RIGHT-TRIM COMMON-LISP::NO-NEXT-METHOD
+   COMMON-LISP::STEP COMMON-LISP::BIT-NOR COMMON-LISP::ARRAY-TOTAL-SIZE
+   COMMON-LISP::ECHO-STREAM COMMON-LISP::FMAKUNBOUND
+   COMMON-LISP::FUNCTION-KEYWORDS COMMON-LISP::SUBST-IF
+   COMMON-LISP::GET-DECODED-TIME COMMON-LISP::LONG-FLOAT
+   COMMON-LISP::SIMPLE-WARNING COMMON-LISP::RATIO COMMON-LISP::EVENP
+   COMMON-LISP::QUOTE WALKER::NEWNEWNEWFORM COMMON-LISP::SIMPLE-STRING
+   COMMON-LISP::NSUBSTITUTE COMMON-LISP::DESCRIBE-OBJECT
+   COMMON-LISP::LAST COMMON-LISP::NSET-DIFFERENCE COMMON-LISP::COUNT
+   COMMON-LISP::CDAAAR COMMON-LISP::SET-DIFFERENCE WALKER::RELIST*
+   WALKER::KEY-ARGS COMMON-LISP::PPRINT
+   COMMON-LISP::SHORT-FLOAT-EPSILON
+   COMMON-LISP::SHORT-FLOAT-NEGATIVE-EPSILON COMMON-LISP::ACOSH
+   COMMON-LISP::LISTEN COMMON-LISP::GENTEMP COMMON-LISP::ERROR
+   COMMON-LISP::ADJUST-ARRAY COMMON-LISP::ALLOCATE-INSTANCE
+   COMMON-LISP::IF COMMON-LISP::CAAAAR
+   COMMON-LISP::SET-SYNTAX-FROM-CHAR COMMON-LISP::STRING-TRIM
+   COMMON-LISP::DIGIT-CHAR COMMON-LISP::BOOLE-AND
+   COMMON-LISP::*COMPILE-PRINT* COMMON-LISP::STRING> COMMON-LISP::CAAAR
+   WALKER::ENV-WALK-FORM COMMON-LISP::GETHASH
+   COMMON-LISP::METHOD-QUALIFIERS COMMON-LISP::FILL-POINTER
+   COMMON-LISP::METHOD-COMBINATION-ERROR COMMON-LISP::CDADDR
+   COMMON-LISP::REMOVE-METHOD COMMON-LISP::DIRECTORY-NAMESTRING
+   COMMON-LISP::DEFUN COMMON-LISP::TRUNCATE WALKER::BLOCK-NAME
+   COMMON-LISP::ALPHA-CHAR-P COMMON-LISP::SYMBOL-FUNCTION
+   COMMON-LISP::SUBSTITUTE-IF-NOT COMMON-LISP::LDB-TEST
+   COMMON-LISP::FLOAT-DIGITS COMMON-LISP::BIT-VECTOR-P
+   COMMON-LISP::REINITIALIZE-INSTANCE COMMON-LISP::PRINT-OBJECT
+   COMMON-LISP::CAADDR COMMON-LISP::VARIABLE COMMON-LISP::NUMERATOR
+   COMMON-LISP::NOTINLINE COMMON-LISP::CHAR-LESSP COMMON-LISP::WARN
+   COMMON-LISP::TYPE-ERROR-DATUM COMMON-LISP::CHAR-NOT-LESSP
+   COMMON-LISP::ARRAY-DIMENSION-LIMIT COMMON-LISP::MOD
+   WALKER::INNER-RESULT COMMON-LISP::SXHASH
+   COMMON-LISP::STREAM-EXTERNAL-FORMAT COMMON-LISP::PACKAGE-USE-LIST
+   COMMON-LISP::PACKAGE-USED-BY-LIST COMMON-LISP::MACHINE-INSTANCE
+   WALKER::ID COMMON-LISP::ARRAYP COMMON-LISP::*GENSYM-COUNTER*
+   COMMON-LISP::UPPER-CASE-P COMMON-LISP::*PRINT-CIRCLE*
+   COMMON-LISP::FTYPE COMMON-LISP::THE WALKER::WALK-LAMBDA WALKER::NAME
+   WALKER::COMPILER-LET COMMON-LISP::SET-PPRINT-DISPATCH
+   COMMON-LISP::COPY-PPRINT-DISPATCH COMMON-LISP::WRITE-TO-STRING
+   COMMON-LISP::ARRAY-TOTAL-SIZE-LIMIT WALKER::WALK-COMPILER-LET
+   COMMON-LISP::SEQUENCE COMMON-LISP::FILE-AUTHOR
+   COMMON-LISP::MULTIPLE-VALUE-CALL COMMON-LISP::*MACROEXPAND-HOOK*
+   COMMON-LISP::PLUSP COMMON-LISP::INTERNAL-TIME-UNITS-PER-SECOND
+   COMMON-LISP::LIST* COMMON-LISP::*PRINT-ARRAY*
+   COMMON-LISP::FILE-WRITE-DATE COMMON-LISP::LAMBDA COMMON-LISP::ED
+   WALKER::BLOCKED-PROG COMMON-LISP::OPEN COMMON-LISP::AREF
+   COMMON-LISP::CALL-METHOD COMMON-LISP::*PRINT-PPRINT-DISPATCH*
+   COMMON-LISP::RASSOC-IF COMMON-LISP::LOGORC1 COMMON-LISP::PROCLAIM
+   WALKER::RELIST-INTERNAL WALKER::PREDICATE COMMON-LISP::DEFMETHOD
+   COMMON-LISP::BROADCAST-STREAM-STREAMS WALKER::WALK-DECLARATIONS
+   COMMON-LISP::APPEND COMMON-LISP::CONCATENATE
+   COMMON-LISP::WRITE-STRING COMMON-LISP::MISMATCH WALKER::SUBFORM
+   WALKER::BINDINGS COMMON-LISP::SIMPLE-STRING-P COMMON-LISP::PRINT
+   COMMON-LISP::MULTIPLE-VALUES-LIMIT COMMON-LISP::PRIN1-TO-STRING
+   COMMON-LISP::PRINC-TO-STRING COMMON-LISP::FIND-METHOD
+   COMMON-LISP::SIMPLE-CONDITION COMMON-LISP::TERPRI
+   COMMON-LISP::CDAADR COMMON-LISP::FLOATING-POINT-OVERFLOW
+   COMMON-LISP::FLOATING-POINT-UNDERFLOW
+   COMMON-LISP::CALL-ARGUMENTS-LIMIT COMMON-LISP::COPY-SEQ
+   COMMON-LISP::FUNCALL
+   WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
+   COMMON-LISP::CLRHASH COMMON-LISP::SHORT-SITE-NAME
+   COMMON-LISP::LOAD-TIME-VALUE COMMON-LISP::LONG-FLOAT-EPSILON
+   COMMON-LISP::LONG-FLOAT-NEGATIVE-EPSILON COMMON-LISP::ASSOC-IF-NOT
+   COMMON-LISP::MAKE-METHOD COMMON-LISP::CAAADR
+   COMMON-LISP::SLOT-MAKUNBOUND WALKER::WALK-TAGBODY WALKER::MVB
+   COMMON-LISP::LOGANDC1 COMMON-LISP::WITH-PACKAGE-ITERATOR
+   COMMON-LISP::SLOT-BOUNDP COMMON-LISP::NUMBERP COMMON-LISP::COMPLEX
+   WALKER::TEMPLATE COMMON-LISP::INVOKE-RESTART-INTERACTIVELY
+   COMMON-LISP::IGNORE-ERRORS COMMON-LISP::AND COMMON-LISP::EVAL-WHEN
+   COMMON-LISP::LOOP COMMON-LISP::READ-FROM-STRING
+   COMMON-LISP::*STANDARD-OUTPUT* COMMON-LISP::CHAR-NAME
+   COMMON-LISP::COMPILE-FILE COMMON-LISP::FLOAT
+   COMMON-LISP::*ERROR-OUTPUT* WALKER::WALK-SETQ
+   WALKER::WITH-NEW-DEFINITION-IN-ENVIRONMENT COMMON-LISP::TYPE-ERROR
+   COMMON-LISP::PPRINT-TABULAR COMMON-LISP::COMPILATION-SPEED
+   COMMON-LISP::LOGXOR COMMON-LISP::LIST-LENGTH COMMON-LISP::DRIBBLE
+   COMMON-LISP::EXTENDED-CHAR COMMON-LISP::MAP COMMON-LISP::WITH-SLOTS
+   WALKER::EFFECT COMMON-LISP::ARRAY-ELEMENT-TYPE
+   COMMON-LISP::FDEFINITION COMMON-LISP::ROUND
+   COMMON-LISP::STRING-LEFT-TRIM COMMON-LISP::DECLAIM COMMON-LISP::SIN
+   COMMON-LISP::*PRINT-LENGTH* COMMON-LISP::DECLARATION
+   COMMON-LISP::STORE-VALUE COMMON-LISP::INTERACTIVE-STREAM-P
+   COMMON-LISP::DECODE-FLOAT COMMON-LISP::PATHNAME-NAME
+   COMMON-LISP::STRING= WALKER::WALK-LET WALKER::WALKED
+   COMMON-LISP::PHASE COMMON-LISP::DEFINE-METHOD-COMBINATION
+   WALKER::OUTER-RESULT WALKER::VALS COMMON-LISP::RASSOC
+   COMMON-LISP::LISP-IMPLEMENTATION-TYPE COMMON-LISP::UNTRACE
+   COMMON-LISP::PRINT-NOT-READABLE COMMON-LISP::ARRAY-ROW-MAJOR-INDEX
+   COMMON-LISP::DEFINE-SETF-EXPANDER COMMON-LISP::SUBSTITUTE-IF
+   WALKER::BINDING COMMON-LISP::BOOLE COMMON-LISP::TRUENAME
+   COMMON-LISP::DEFCONSTANT COMMON-LISP::OPEN-STREAM-P
+   COMMON-LISP::VALUES-LIST COMMON-LISP::&REST
+   COMMON-LISP::MAKE-RANDOM-STATE COMMON-LISP::CHAR>
+   COMMON-LISP::BYTE-SIZE COMMON-LISP::MIN COMMON-LISP::CDDDR
+   COMMON-LISP::BIT-IOR COMMON-LISP::WITH-STANDARD-IO-SYNTAX
+   COMMON-LISP::VECTOR COMMON-LISP::INVOKE-RESTART
+   COMMON-LISP::UNSIGNED-BYTE WALKER::WALK-LET/LET*
+   COMMON-LISP::SERIOUS-CONDITION COMMON-LISP::SYMBOL-PLIST
+   WALKER::MACROLET/FLET/LABELS-FORM COMMON-LISP::*READTABLE*
+   COMMON-LISP::SIMPLE-BIT-VECTOR-P
+   COMMON-LISP::LEAST-POSITIVE-SHORT-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-SINGLE-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-DOUBLE-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-LONG-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
+   COMMON-LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT
+   COMMON-LISP::LOWER-CASE-P COMMON-LISP::EQUALP
+   COMMON-LISP::SUBSTITUTE COMMON-LISP::SUBSEQ COMMON-LISP::MINUSP
+   COMMON-LISP::SIMPLE-CONDITION-FORMAT-CONTROL
+   COMMON-LISP::MOST-NEGATIVE-SHORT-FLOAT
+   COMMON-LISP::MOST-NEGATIVE-SINGLE-FLOAT
+   COMMON-LISP::MOST-NEGATIVE-DOUBLE-FLOAT
+   COMMON-LISP::MOST-NEGATIVE-LONG-FLOAT COMMON-LISP::FILE-LENGTH
+   COMMON-LISP::FILE-ERROR COMMON-LISP::HASH-TABLE
+   WALKER::NOTE-DECLARATION COMMON-LISP::SPEED
+   COMMON-LISP::*PRINT-RADIX* COMMON-LISP::ECHO-STREAM-INPUT-STREAM
+   COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM COMMON-LISP::UNBOUND-VARIABLE
+   COMMON-LISP::RATIONAL COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE
+   COMMON-LISP::FRESH-LINE WALKER::WALKED-ARGLIST COMMON-LISP::WHEN
+   COMMON-LISP::COMPILE COMMON-LISP::HASH-TABLE-REHASH-SIZE
+   COMMON-LISP::FLET COMMON-LISP::SPECIAL COMMON-LISP::CLASS
+   WALKER::WALK-MULTIPLE-VALUE-BIND COMMON-LISP::CELL-ERROR
+   COMMON-LISP::RPLACD COMMON-LISP::TYPE-OF
+   COMMON-LISP::SPECIAL-OPERATOR-P COMMON-LISP::PATHNAME-MATCH-P
+   WALKER::ENV-LOCK COMMON-LISP::DESCRIBE COMMON-LISP::POSITION
+   COMMON-LISP::STABLE-SORT COMMON-LISP::BOTH-CASE-P
+   COMMON-LISP::SYMBOLP COMMON-LISP::*PRINT-READABLY* WALKER::WHOLE
+   COMMON-LISP::SHADOW COMMON-LISP::STREAM COMMON-LISP::MAKE-ARRAY
+   COMMON-LISP::FUNCTIONP WALKER::CONTEXT COMMON-LISP::&WHOLE
+   COMMON-LISP::SUBST COMMON-LISP::SCHAR COMMON-LISP::ARRAY-DIMENSION
+   WALKER::LEXICAL-VARIABLES COMMON-LISP::COND
+   COMMON-LISP::DO-EXTERNAL-SYMBOLS COMMON-LISP::CHAR-CODE-LIMIT
+   COMMON-LISP::SATISFIES COMMON-LISP::MASK-FIELD
+   COMMON-LISP::ARITHMETIC-ERROR WALKER::WALK-LET* COMMON-LISP::CADDR
+   COMMON-LISP::LAMBDA-LIST-KEYWORDS COMMON-LISP::STRING-NOT-EQUAL
+   COMMON-LISP::CONTINUE COMMON-LISP::STRING-LESSP
+   COMMON-LISP::USE-PACKAGE COMMON-LISP::MULTIPLE-VALUE-SETQ
+   WALKER::WALKER-ENVIRONMENT-BIND-1 WALKER::ARM2 COMMON-LISP::>=
+   COMMON-LISP::LOGEQV COMMON-LISP::HASH-TABLE-P
+   COMMON-LISP::GRAPHIC-CHAR-P COMMON-LISP::PRINT-UNREADABLE-OBJECT
+   COMMON-LISP::EQL COMMON-LISP::MAPHASH COMMON-LISP::NINTERSECTION
+   COMMON-LISP::<= WALKER::WFOP COMMON-LISP::NAMESTRING
+   COMMON-LISP::MAKE-CONCATENATED-STREAM COMMON-LISP::MAKE-INSTANCE
+   COMMON-LISP::SHORT-FLOAT COMMON-LISP::FILE-STREAM
+   COMMON-LISP::WRITE-LINE COMMON-LISP::VECTOR-PUSH COMMON-LISP::ENDP
+   WALKER::WALK-TAGBODY-1 WALKER::WALK-FUNCTION WALKER::REPEAT
+   COMMON-LISP::DIRECTORY COMMON-LISP::TYPE COMMON-LISP::ASSOC-IF
+   COMMON-LISP::DPB COMMON-LISP::TYPEP COMMON-LISP::FIFTH
+   WALKER::GET-WALKER-TEMPLATE-INTERNAL COMMON-LISP::LOGNAND
+   COMMON-LISP::SIGNED-BYTE COMMON-LISP::EVERY WALKER::DECLARATIONS
+   WALKER::SYMMAC COMMON-LISP::PPRINT-POP COMMON-LISP::SUBLIS
+   COMMON-LISP::NULL COMMON-LISP::FLOATP COMMON-LISP::STRING<
+   COMMON-LISP::*TRACE-OUTPUT* WALKER::CONVERT-MACRO-TO-LAMBDA
+   COMMON-LISP::WRITE-CHAR COMMON-LISP::*DEBUGGER-HOOK*
+   COMMON-LISP::*PRINT-RIGHT-MARGIN*
+   COMMON-LISP::STANDARD-GENERIC-FUNCTION COMMON-LISP::MAPL
+   COMMON-LISP::PROG1 COMMON-LISP::COMPLEXP COMMON-LISP::INSPECT
+   COMMON-LISP::MACROEXPAND-1 COMMON-LISP::BIT-ANDC1 COMMON-LISP::SETQ
+   COMMON-LISP::CHAR>= COMMON-LISP::READTABLE-CASE
+   COMMON-LISP::REALPART COMMON-LISP::LDIFF COMMON-LISP::SINH
+   COMMON-LISP::BROADCAST-STREAM COMMON-LISP::MAKE-STRING
+   COMMON-LISP::BASE-STRING WALKER::SETS COMMON-LISP::CDDDAR
+   COMMON-LISP::INTEGER-LENGTH COMMON-LISP::OUTPUT-STREAM-P
+   COMMON-LISP::NUNION COMMON-LISP::/= COMMON-LISP::SLOT-MISSING
+   COMMON-LISP::PACKAGE-NAME COMMON-LISP::ECASE
+   COMMON-LISP::INVOKE-DEBUGGER COMMON-LISP::PATHNAME
+   COMMON-LISP::APPLY COMMON-LISP::CHAR-INT COMMON-LISP::TAN
+   COMMON-LISP::MOST-NEGATIVE-FIXNUM COMMON-LISP::MAKE-SYNONYM-STREAM
+   WALKER::WALK-BINDINGS-2 WALKER::WALK-LABELS WALKER::ENV
+   COMMON-LISP::MACROEXPAND COMMON-LISP::CADDAR COMMON-LISP::ISQRT
+   COMMON-LISP::CCASE COMMON-LISP::COMPUTE-APPLICABLE-METHODS
+   COMMON-LISP::GCD WALKER::WALK-FORM-INTERNAL WALKER::LEXICALS
+   WALKER::DESTRUCTURINGP COMMON-LISP::KEYWORD COMMON-LISP::UNLESS
+   COMMON-LISP::MAP-INTO COMMON-LISP::*LOAD-TRUENAME*
+   COMMON-LISP::SIMPLE-ERROR COMMON-LISP::SYNONYM-STREAM
+   WALKER::WALK-FLET COMMON-LISP::SUBSETP COMMON-LISP::POSITION-IF
+   COMMON-LISP::INCF WALKER::NEW-ENV WALKER::REPEAT-TEMPLATE
+   COMMON-LISP::SHIFTF COMMON-LISP::BOOLE-XOR COMMON-LISP::REM
+   COMMON-LISP::LOGNOR WALKER::WALK-TEMPLATE
+   WALKER::NOTE-LEXICAL-BINDING WALKER::FORM WALKER::ENVIRONMENT
+   COMMON-LISP::FIND COMMON-LISP::MAX COMMON-LISP::GET-SETF-EXPANSION
+   COMMON-LISP::PPRINT-DISPATCH COMMON-LISP::SIMPLE-VECTOR-P
+   COMMON-LISP::SLOT-EXISTS-P COMMON-LISP::IMPORT
+   COMMON-LISP::MACHINE-VERSION COMMON-LISP::SHADOWING-IMPORT
+   COMMON-LISP::BOOLE-EQV COMMON-LISP::CONJUGATE
+   COMMON-LISP::READ-CHAR-NO-HANG COMMON-LISP::WRITE-BYTE
+   COMMON-LISP::WITH-OUTPUT-TO-STRING COMMON-LISP::BYTE-POSITION
+   COMMON-LISP::STANDARD-CHAR COMMON-LISP::STRING
+   COMMON-LISP::MEMBER-IF WALKER::WFNP WALKER::X
+   COMMON-LISP::NSTRING-UPCASE COMMON-LISP::DEFMACRO
+   COMMON-LISP::BUTLAST COMMON-LISP::NEXT-METHOD-P COMMON-LISP::CDDAAR
+   COMMON-LISP::RESTART-BIND COMMON-LISP::IMAGPART
+   COMMON-LISP::LOGANDC2 COMMON-LISP::HASH-TABLE-SIZE
+   COMMON-LISP::*COMPILE-VERBOSE* COMMON-LISP::FFLOOR
+   COMMON-LISP::INVALID-METHOD-ERROR COMMON-LISP::DEFGENERIC
+   COMMON-LISP::*PRINT-LEVEL* COMMON-LISP::DEFSTRUCT
+   COMMON-LISP::DELETE-PACKAGE COMMON-LISP::BOOLE-CLR
+   COMMON-LISP::DO-SYMBOLS COMMON-LISP::INTEGERP COMMON-LISP::NUMBER
+   COMMON-LISP::CADAAR COMMON-LISP::NIL COMMON-LISP::T
+   WALKER::*KEY-TO-WALKER-ENVIRONMENT* COMMON-LISP::DELETE
+   COMMON-LISP::DEFINE-MODIFY-MACRO
+   COMMON-LISP::ENSURE-GENERIC-FUNCTION COMMON-LISP::COMPILED-FUNCTION
+   COMMON-LISP::NOTEVERY COMMON-LISP::BOOLE-2 COMMON-LISP::STRUCTURE
+   COMMON-LISP::PPRINT-LINEAR COMMON-LISP::FIND-RESTART
+   COMMON-LISP::UNBOUND-SLOT COMMON-LISP::RENAME-PACKAGE
+   COMMON-LISP::SIGNUM COMMON-LISP::CDDDDR WALKER::LAMBDA-BLOCK
+   COMMON-LISP::FILE-POSITION COMMON-LISP::LOGBITP
+   COMMON-LISP::STANDARD-METHOD COMMON-LISP::PSETQ
+   COMMON-LISP::SIMPLE-CONDITION-FORMAT-ARGUMENTS COMMON-LISP::EVAL
+   COMMON-LISP::CHAR-GREATERP COMMON-LISP::CERROR
+   COMMON-LISP::UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
+   COMMON-LISP::UPDATE-INSTANCE-FOR-REDEFINED-CLASS
+   COMMON-LISP::SYMBOL-VALUE COMMON-LISP::+++ WALKER::M
+   COMMON-LISP::LCM COMMON-LISP::BOOLE-NAND COMMON-LISP::SIMPLE-ARRAY
+   COMMON-LISP::CADDDR COMMON-LISP::SIMPLE-BIT-VECTOR
+   COMMON-LISP::PRIN1 COMMON-LISP::BIT-ORC1
+   COMMON-LISP::*LOAD-PATHNAME* WALKER::WALK-SYMBOL-MACROLET
+   WALKER::ARGS COMMON-LISP::STREAM-ERROR-STREAM COMMON-LISP::PSETF
+   COMMON-LISP::RETURN COMMON-LISP::MAKE-PATHNAME
+   COMMON-LISP::TYPE-ERROR-EXPECTED-TYPE
+   COMMON-LISP::FILE-STRING-LENGTH COMMON-LISP::DOTIMES
+   COMMON-LISP::DEPOSIT-FIELD COMMON-LISP::*QUERY-IO*
+   COMMON-LISP::MAKE-CONDITION COMMON-LISP::&ENVIRONMENT
+   COMMON-LISP::ARRAY-DIMENSIONS COMMON-LISP::MAKE-BROADCAST-STREAM
+   COMMON-LISP::BOOLE-ANDC2 COMMON-LISP::MAKE-TWO-WAY-STREAM
+   COMMON-LISP::INPUT-STREAM-P WALKER::ARGLIST
+   COMMON-LISP::DIGIT-CHAR-P WALKER::LEXP COMMON-LISP::*STANDARD-INPUT*
+   COMMON-LISP::BOUNDP COMMON-LISP::ODDP
+   COMMON-LISP::READ-DELIMITED-LIST WALKER::F
+   COMMON-LISP::ARITHMETIC-ERROR-OPERANDS COMMON-LISP::SIXTH
+   WALKER::MAC WALKER::E COMMON-LISP::SUBTYPEP
+   COMMON-LISP::NSTRING-CAPITALIZE COMMON-LISP::DECLARE
+   COMMON-LISP::FLOOR WALKER::STOP-FORM COMMON-LISP::GENSYM
+   COMMON-LISP::ARRAY-HAS-FILL-POINTER-P COMMON-LISP::LOGIOR WALKER::C
+   COMMON-LISP::Y-OR-N-P COMMON-LISP::PARSE-NAMESTRING
+   COMMON-LISP::ARRAY-RANK COMMON-LISP::NINTH
+   COMMON-LISP::WITH-INPUT-FROM-STRING COMMON-LISP::INTEGER
+   COMMON-LISP::MAKE-SEQUENCE COMMON-LISP::SET-EXCLUSIVE-OR
+   COMMON-LISP::CHAR< COMMON-LISP::INLINE COMMON-LISP::CDDADR
+   COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::TANH COMMON-LISP::ATAN
+   COMMON-LISP::NOT COMMON-LISP::LONG-SITE-NAME
+   COMMON-LISP::PATHNAME-VERSION COMMON-LISP::MAPCAN
+   COMMON-LISP::REQUIRE WALKER::WALK-NO-MORE-P COMMON-LISP::RPLACA
+   COMMON-LISP::TAGBODY COMMON-LISP::COPY-ALIST COMMON-LISP::CADADR
+   COMMON-LISP::MAPCAR COMMON-LISP::RESTART-NAME COMMON-LISP::>
+   WALKER::WALK-REPEAT-EVAL COMMON-LISP::FIND-PACKAGE
+   COMMON-LISP::FBOUNDP COMMON-LISP::DEFINE-SYMBOL-MACRO COMMON-LISP::=
+   WALKER::WALK-PROG WALKER::WALK-PROG* COMMON-LISP::DEFSETF
+   COMMON-LISP::ZEROP COMMON-LISP::UNUSE-PACKAGE
+   COMMON-LISP::MOST-POSITIVE-SHORT-FLOAT
+   COMMON-LISP::MOST-POSITIVE-SINGLE-FLOAT
+   COMMON-LISP::MOST-POSITIVE-DOUBLE-FLOAT
+   COMMON-LISP::MOST-POSITIVE-LONG-FLOAT COMMON-LISP::LOGICAL-PATHNAME
+   COMMON-LISP::< WALKER::WALK-ARGLIST COMMON-LISP::LOGCOUNT
+   COMMON-LISP::ENOUGH-NAMESTRING COMMON-LISP::MULTIPLE-VALUE-LIST
+   COMMON-LISP::TWO-WAY-STREAM COMMON-LISP::CDDR COMMON-LISP::ASSOC
+   COMMON-LISP::REMF COMMON-LISP::LDB COMMON-LISP::MACROLET
+   COMMON-LISP::CDADR WALKER::WALK-DO COMMON-LISP::UNION
+   COMMON-LISP::FIND-ALL-SYMBOLS COMMON-LISP::MAKE-PACKAGE
+   WALKER::WALK-LOCALLY COMMON-LISP::&OPTIONAL
+   COMMON-LISP::COPY-STRUCTURE COMMON-LISP::THIRD COMMON-LISP::LABELS
+   COMMON-LISP::BOOLE-C1 COMMON-LISP::PPRINT-INDENT
+   WALKER::WALK-MACROLET WALKER::TEMP COMMON-LISP::FIND-IF-NOT
+   COMMON-LISP::FORMATTER COMMON-LISP::HANDLER-CASE WALKER::NEWNEWFORM
+   WALKER::REAL-ENV COMMON-LISP::LOAD COMMON-LISP::DELETE-IF-NOT
+   COMMON-LISP::ACONS COMMON-LISP::UNDEFINED-FUNCTION
+   COMMON-LISP::WILD-PATHNAME-P COMMON-LISP::PACKAGEP
+   COMMON-LISP::ENCODE-UNIVERSAL-TIME WALKER::VAL COMMON-LISP::FORMAT
+   COMMON-LISP::TENTH COMMON-LISP::STRUCTURE-CLASS
+   COMMON-LISP::MEMBER-IF-NOT COMMON-LISP::LEAST-NEGATIVE-SHORT-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-SINGLE-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-LONG-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
+   COMMON-LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT
+   WALKER::WALK-MULTIPLE-VALUE-SETQ WALKER::GET-WALKER-TEMPLATE
+   COMMON-LISP::BOOLE-1 COMMON-LISP::REDUCE WALKER::WALK-NAMED-LAMBDA
+   WALKER::WALKED-BODY COMMON-LISP::SVREF
+   COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::NTH-VALUE
+   COMMON-LISP::FORCE-OUTPUT COMMON-LISP::NSUBSTITUTE-IF-NOT
+   COMMON-LISP::CATCH COMMON-LISP::STORAGE-CONDITION
+   COMMON-LISP::USE-VALUE COMMON-LISP::MERGE COMMON-LISP::CASE
+   COMMON-LISP::CLEAR-INPUT COMMON-LISP::MUFFLE-WARNING
+   COMMON-LISP::REPLACE COMMON-LISP::*** COMMON-LISP::GENERIC-FUNCTION
+   COMMON-LISP::/ COMMON-LISP::BOOLE-SET COMMON-LISP::SOFTWARE-VERSION
+   COMMON-LISP::APROPOS-LIST COMMON-LISP::POSITION-IF-NOT
+   COMMON-LISP::READ-BYTE COMMON-LISP::FLOAT-RADIX
+   WALKER::ENVIRONMENT-MACRO COMMON-LISP::DECF COMMON-LISP::PROG
+   COMMON-LISP::CALL-NEXT-METHOD COMMON-LISP::- WALKER::OLD-BODY
+   COMMON-LISP::MAPCON COMMON-LISP::CELL-ERROR-NAME
+   WALKER::WALKED-BINDING COMMON-LISP::INITIALIZE-INSTANCE
+   COMMON-LISP::CADR COMMON-LISP::EQUAL COMMON-LISP::CAADR
+   COMMON-LISP::MAKE-LOAD-FORM COMMON-LISP::WITH-SIMPLE-RESTART
+   COMMON-LISP::+ WALKER::DECL COMMON-LISP::PATHNAME-DEVICE
+   COMMON-LISP::MACRO-FUNCTION COMMON-LISP::MAPLIST
+   COMMON-LISP::REVERSE COMMON-LISP::FIND-SYMBOL COMMON-LISP::*
+   COMMON-LISP::LOCALLY COMMON-LISP::BIT-ANDC2 COMMON-LISP::*FEATURES*
+   COMMON-LISP::DIVISION-BY-ZERO COMMON-LISP::ARRAY WALKER::DECP
+   COMMON-LISP::DEFPARAMETER COMMON-LISP::PATHNAME-DIRECTORY
+   COMMON-LISP::WITH-CONDITION-RESTARTS COMMON-LISP::STRING-NOT-LESSP
+   COMMON-LISP::ELT COMMON-LISP::NTH COMMON-LISP::RETURN-FROM
+   COMMON-LISP::COMPILER-MACRO COMMON-LISP::BIGNUM
+   COMMON-LISP::PACKAGE-ERROR-PACKAGE COMMON-LISP::MAKE-SYMBOL
+   COMMON-LISP::WITH-COMPILATION-UNIT COMMON-LISP::FILL
+   COMMON-LISP::CHAR-CODE WALKER::LET/LET* COMMON-LISP::*PRINT-ESCAPE*
+   COMMON-LISP::*PRINT-BASE* COMMON-LISP::*PRINT-CASE*
+   COMMON-LISP::FLOATING-POINT-INVALID-OPERATION COMMON-LISP::NSUBST
+   COMMON-LISP::SIMPLE-VECTOR COMMON-LISP::ARRAY-IN-BOUNDS-P
+   COMMON-LISP::READ-PRESERVING-WHITESPACE COMMON-LISP::ATANH
+   COMMON-LISP::ATOM COMMON-LISP::BIT-NAND WALKER::THING
+   COMMON-LISP::RESTART COMMON-LISP::VECTOR-POP COMMON-LISP::MEMBER
+   WALKER::VARS COMMON-LISP::REMOVE COMMON-LISP::PPRINT-TAB
+   COMMON-LISP::CHAR<= COMMON-LISP::PUSH COMMON-LISP::PROGRAM-ERROR
+   WALKER::TEMPS COMMON-LISP::CHAR-UPCASE COMMON-LISP::*PRINT-PRETTY*
+   COMMON-LISP::MOST-POSITIVE-FIXNUM COMMON-LISP::PATHNAME-HOST
+   COMMON-LISP::DOCUMENTATION COMMON-LISP:://
+   COMMON-LISP::SHARED-INITIALIZE COMMON-LISP::UNEXPORT
+   COMMON-LISP::PROBE-FILE COMMON-LISP::STANDARD-CLASS
+   COMMON-LISP::GET-INTERNAL-RUN-TIME
+   COMMON-LISP::GET-INTERNAL-REAL-TIME COMMON-LISP::NOTANY
+   WALKER::.LET-IF-DUMMY. COMMON-LISP::COMPILER-MACRO-FUNCTION
+   COMMON-LISP::ROOM COMMON-LISP::UNBOUND-SLOT-INSTANCE
+   COMMON-LISP::COS COMMON-LISP::CHAR-DOWNCASE COMMON-LISP::CONSTANTLY
+   COMMON-LISP::RATIONALIZE COMMON-LISP::LISP-IMPLEMENTATION-VERSION
+   COMMON-LISP::CONSTANTP COMMON-LISP::HASH-TABLE-COUNT
+   COMMON-LISP::STREAMP COMMON-LISP::NO-APPLICABLE-METHOD
+   WALKER::NEWFORM WALKER::ENV-WALK-FUNCTION COMMON-LISP::1-
+   COMMON-LISP::BIT-XOR COMMON-LISP::STRING-STREAM
+   COMMON-LISP::GET-PROPERTIES COMMON-LISP::COUNT-IF-NOT
+   COMMON-LISP::BIT COMMON-LISP::ASH COMMON-LISP::NSUBLIS
+   COMMON-LISP::PPRINT-LOGICAL-BLOCK COMMON-LISP::FIND-CLASS
+   COMMON-LISP::FOURTH COMMON-LISP::STRING<= COMMON-LISP::STRING>=
+   COMMON-LISP::STRING/= COMMON-LISP::SLEEP WALKER::MACROS
+   WALKER::MV-FORM COMMON-LISP::TREE-EQUAL
+   COMMON-LISP::DEFINE-CONDITION COMMON-LISP::SET
+   COMMON-LISP::STRING-GREATERP COMMON-LISP::SINGLE-FLOAT-EPSILON
+   COMMON-LISP::SINGLE-FLOAT-NEGATIVE-EPSILON COMMON-LISP::COMPLEMENT
+   COMMON-LISP::WRITE COMMON-LISP::NCONC
+   COMMON-LISP::DECODE-UNIVERSAL-TIME COMMON-LISP::*PRINT-MISER-WIDTH*
+   COMMON-LISP::BUILT-IN-CLASS COMMON-LISP::*RANDOM-STATE*
+   COMMON-LISP::*COMPILE-FILE-PATHNAME*
+   COMMON-LISP::*COMPILE-FILE-TRUENAME*
+   WALKER::WALK-TEMPLATE-HANDLE-REPEAT WALKER::WALKED-BINDINGS
+   WALKER::RFORMS WALKER::WALK-DEFINITIONS COMMON-LISP::BOOLE-ORC1
+   COMMON-LISP::BOOLE-ORC2 COMMON-LISP::FILE-NAMESTRING
+   COMMON-LISP::BIT-ORC2 COMMON-LISP::1+
+   COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM
+   COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM COMMON-LISP::PROG2
+   COMMON-LISP::*READ-SUPPRESS* COMMON-LISP::PPRINT-FILL
+   COMMON-LISP::DOLIST COMMON-LISP::SIMPLE-BASE-STRING
+   COMMON-LISP::SLOT-VALUE COMMON-LISP::LET
+   COMMON-LISP::CHAR-NOT-GREATERP COMMON-LISP::PATHNAMEP
+   COMMON-LISP::READ COMMON-LISP::RANDOM-STATE-P
+   COMMON-LISP::*READ-EVAL* COMMON-LISP::CDDAR COMMON-LISP::REMOVE-IF
+   COMMON-LISP::&ALLOW-OTHER-KEYS WALKER::OUTER-WALK-FUNCTION
+   COMMON-LISP::FROUND COMMON-LISP::CHAR-EQUAL
+   COMMON-LISP::MAKE-DISPATCH-MACRO-CHARACTER COMMON-LISP::EIGHTH
+   COMMON-LISP::OPTIMIZE WALKER::RECONS COMMON-LISP::++
+   COMMON-LISP::DO* COMMON-LISP::SIMPLE-TYPE-ERROR COMMON-LISP::ASIN
+   COMMON-LISP::SINGLE-FLOAT COMMON-LISP::REAL COMMON-LISP::CHARACTER
+   COMMON-LISP::CHARACTERP COMMON-LISP::GET
+   WALKER::ENV-LEXICAL-VARIABLES COMMON-LISP::REALP
+   COMMON-LISP::FCEILING COMMON-LISP::COPY-SYMBOL
+   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS COMMON-LISP::CHAR
+   WALKER::EXPANDED COMMON-LISP::STANDARD-CHAR-P
+   COMMON-LISP::*DEBUG-IO* COMMON-LISP::FIXNUM
+   COMMON-LISP::COMPILED-FUNCTION-P WALKER::WALK-UNEXPECTED-DECLARE
+   COMMON-LISP::COUNT-IF COMMON-LISP::** COMMON-LISP::COMPUTE-RESTARTS
+   COMMON-LISP::METHOD COMMON-LISP::WITH-OPEN-FILE COMMON-LISP::PACKAGE
+   COMMON-LISP::IGNORE COMMON-LISP::IDENTITY COMMON-LISP::CTYPECASE
+   COMMON-LISP::ETYPECASE COMMON-LISP::PROGV
+   COMMON-LISP::WITH-ACCESSORS COMMON-LISP::NSUBSTITUTE-IF
+   COMMON-LISP::BOOLE-NOR)
+ "WALKER")
+
 ;;; Definitions for package ITERATE of type SHADOW
 (COMMON-LISP::SHADOW 'COMMON-LISP::NIL "ITERATE")
 (COMMON-LISP::SHADOWING-IMPORT 'COMMON-LISP::NIL "ITERATE")
@@ -2133,88 +2133,90 @@
    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 ARGUMENTS-LAMBDA-LIST)|
-   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 SLOT-OBJECT PLIST)|
    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 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 SLOT-DEFINITION INITFORM)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-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::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFORM)|
    PCL::%STD-INSTANCE- PCL::.QUALIFIERS. PCL::REMOVE-NAMED-METHOD
    PCL::CACHE-FIELD PCL::INSTANCE-SLOTDS PCL::FSC
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
    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 PROTOTYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
-   PCL::GCL_PCL_SLOTS PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::INSTANCE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)|
+   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
    COMMON-LISP::SIMPLE-CONDITION
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
-   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::|(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::DEFINITIONS PCL::DFUN-INFO-WRAPPER0 PCL::REMTAIL
-   PCL::MAKE-PV-TABLE COMMON-LISP::FLOOR PCL::GET-SYMBOL
-   PCL::METHOD-CALL-P PCL::|__si::MAKE-INITIAL|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DOCUMENTATION)|
-   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::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 MAX-LOCATION)| PCL::PARAMETERS
-   PCL::PARAMETER PCL::BUILT-IN
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   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 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 CLASS)| PCL::FIRST-P
-   PCL::DFUN-INFO-ACCESSOR-TYPE CSTRUCT::C-FLOAT-DOUBLE->
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-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-INDEX-P PCL::ONE-ORDER-P
+   PCL::DEFSTRUCT-P PCL::ONE-ORDER-P PCL::ONE-INDEX-P
    PCL::INTERN-FUNCTION-NAME PCL::SLOTD PCL::INSTANCE-BOUNDP
    PCL::INSTANCE-WRITER CSTRUCT::C-FLOAT-FCOMPLEX-==
    CSTRUCT::C-FLOAT-DCOMPLEX-== PCL::KNOWN-TYPE
@@ -2224,46 +2226,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 SYSTEM::SIZE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SIZE)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LINE-SIZE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SIZE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
    PCL::MAKE-EMF-FROM-METHOD PCL::%SET-CCLOSURE PCL::INITKEYS
    PCL::SDFUN-METHOD PCL::WRAPPERS-MISMATCH-P PCL::GCL_PCL_DLISP
-   PCL::METHOD-NAME PCL::METHOD-FN-NAME PCL::METACLASS PCL::NEW-CLASS
+   PCL::METHOD-FN-NAME PCL::METHOD-NAME PCL::NEW-CLASS PCL::METACLASS
    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-STRUCTURE-INSTANCE PCL::ALLOCATE-STANDARD-INSTANCE
+   PCL::ALLOCATE-STANDARD-INSTANCE PCL::ALLOCATE-STRUCTURE-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-PV-ARGS
-   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::EARLY-CLASS-SLOTDS
+   PCL::MAKE-FGEN PCL::|(BOUNDP SOURCE)| PCL::PV-WRAPPERS-FROM-ALL-ARGS
+   PCL::PV-WRAPPERS-FROM-PV-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 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::|(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::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|
@@ -2317,21 +2319,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::TRANSFORM PCL::TRANSFORMS PCL::NAME-DECL
+   PCL::GFS-TO-DO PCL::TRANSFORMS PCL::TRANSFORM PCL::NAME-DECL
    CSTRUCT::C-PATHNAME-HOST PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST
    COMMON-LISP::PATHNAME-DEVICE PCL::GENERATOR-LAMBDA
    PCL::STANDARD-WRITER-METHOD-P PCL::PORT-DIRECTORY
    PCL::FREE-OLD-CACHE-P COMMON-LISP::SUBSEQ PCL::METATYPE
    CSTRUCT::C-ARRAY-HASFILLP CSTRUCT::C-SYMBOL-HASH
    PCL::CHECK-LAMBDA-LIST
-   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLASSES
-   PCL::CLAUSE PCL::*NAME->CLASS->SLOTD-TABLE*
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLAUSE
+   PCL::CLASSES PCL::*NAME->CLASS->SLOTD-TABLE*
    PCL::EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::INITARGS
-   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL SPECIALIZER|
    PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::PLIST-P
+   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL EQL-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)|
@@ -2353,8 +2355,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::FREE-CACHE
-   PCL::FROM-CACHE PCL::CHECK-QUALIFIERS COMMON-LISP::*QUERY-IO*
+   PCL::FUNCALLABLE-INSTANCE-DATA PCL::EARLY-CLASS-SIZE PCL::FROM-CACHE
+   PCL::FREE-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
@@ -2367,23 +2369,22 @@
    PCL::FOR CSTRUCT::*FLOAT COMMON-LISP::POSITION
    COMMON-LISP::MAKE-SEQUENCE PCL::FIXUP PCL::METHOD-FUNCTION-METHOD
    PCL::CACHED-DEFAULT-INITARGS-FUNCTION
-   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
-   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
    PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
+   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-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-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-INITARGS-FORM-LIST
+   PCL::INITIAL- PCL::INITIALIZE-FORM-LIST
    PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
-   PCL::INITIALIZE-FORM-LIST PCL::|(READER INITARGS)|
-   COMMON-LISP::BOOLE-C2 PCL::RENEW-SYS-FILES
+   PCL::INITIALIZE-INFO-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-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
@@ -2392,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-BOUND-SLOTS PCL::INITIALIZE-INFO-CACHED-SLOTS
+   PCL::INITIALIZE-INFO-CACHED-SLOTS PCL::INITIALIZE-INFO-BOUND-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
@@ -2409,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::OMETHOD PCL::TMETHOD
+   PCL::TMETHOD PCL::OMETHOD
    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
@@ -2422,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-ADD-METHOD)| PCL::|(CALL REAL-REMOVE-METHOD)|
-   PCL::|(CALL REAL-GET-METHOD)| PCL::ONE-INDEX-DFUN-INFO-CACHE
+   PCL::|(CALL REAL-GET-METHOD)| PCL::|(CALL REAL-REMOVE-METHOD)|
+   PCL::|(CALL REAL-ADD-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-DIRECT-SLOTS)|
-   PCL::|(SETF CLASS-SLOTS)| PCL::COMPUTE-LINE-SIZE
+   PCL::WRAPPERS+VALUE PCL::|(SETF CLASS-SLOTS)|
+   PCL::|(SETF CLASS-DIRECT-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
@@ -2439,27 +2440,27 @@
    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::NULL class predicate|
-   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
-   PCL::|COMMON-LISP::SYMBOL class predicate|
-   PCL::|COMMON-LISP::CHARACTER class predicate|
-   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
-   PCL::|COMMON-LISP::STRING class predicate|
-   PCL::|COMMON-LISP::VECTOR class predicate|
-   PCL::|COMMON-LISP::ARRAY class predicate|
-   PCL::|COMMON-LISP::STREAM class predicate|
-   PCL::|COMMON-LISP::FILE-STREAM class predicate|
-   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
-   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
-   PCL::|COMMON-LISP::STRING-STREAM class predicate|
-   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
-   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
-   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
-   PCL::|COMMON-LISP::HASH-TABLE class predicate|
-   PCL::|COMMON-LISP::PACKAGE class predicate|
-   PCL::|COMMON-LISP::READTABLE class predicate|
-   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
    PCL::|COMMON-LISP::PATHNAME class predicate|
+   PCL::|COMMON-LISP::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::NULL class predicate|
    PCL::|COMMON-LISP::CONS class predicate|
    PCL::|COMMON-LISP::LIST class predicate|
    PCL::|COMMON-LISP::SEQUENCE class predicate|
@@ -2719,6 +2720,15 @@
    PCL::|INITIALIZE-INFO SLOT3| PCL::XEROX-PATCHES
    PCL::LIST-LARGE-CACHES PCL::INVALID-WRAPPER-P
    CSTRUCT::C-SET-STRUCTURE-SELF
+   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 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))|
@@ -2797,15 +2807,6 @@
    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::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
-   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
    PCL::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
@@ -2822,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::KLIST-TAIL
-   PCL::ALIST-TAIL PCL::*DEFCLASS-TIMES*
+   PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::ALIST-TAIL
+   PCL::KLIST-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+
@@ -2840,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::GET-CLASS-SLOT-VALUE-1
-   PCL::SET-CLASS-SLOT-VALUE-1 PCL::ENVIRONMENT
+   PCL::*INLINE-IIS-INSTANCE-LOCATIONS-P* PCL::SET-CLASS-SLOT-VALUE-1
+   PCL::GET-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
@@ -2886,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::CLASS-KEY PCL::SLOTS-KEY
+   COMMON-LISP::WITH-OUTPUT-TO-STRING PCL::SLOTS-KEY PCL::CLASS-KEY
    PCL::SLOT-VARS PCL::*PATHNAME-EXTENSIONS* COMMON-LISP::SHIFTF
    COMMON-LISP::RETURN PCL::.CALL. PCL::COPY-CONSTANT-VALUE
-   PCL::LONG-METHOD-COMBINATION-FUNCTION PCL::LONG-METHOD-COMBINATION
+   PCL::LONG-METHOD-COMBINATION PCL::LONG-METHOD-COMBINATION-FUNCTION
    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-P PCL::PV-TABLE- COMMON-LISP::BIT-NOR
+   PCL::PV-TABLE- PCL::PV-TABLE-P 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::|(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-CLASS-EQ-SPECIALIZER*
+   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-SPECIALIZER* CSTRUCT::LISP-TYPE PCL::DFUN-TYPE
+   PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
+   PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
+   PCL::*THE-CLASS-EQL-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 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 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 FROM-DEFCLASS-P)|
    PCL::COPY-ONE-INDEX-DFUN-INFO PCL::|(BOUNDP INITIALIZE-INFO)|
    PCL::ALL PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT* PCL::CACHING
@@ -2926,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-BIT-VECTOR* PCL::*THE-CLASS-CHARACTER*
-   PCL::*THE-CLASS-VECTOR* PCL::ORIGINAL SYSTEM::TP6
+   PCL::*THE-CLASS-VECTOR* PCL::*THE-CLASS-CHARACTER*
+   PCL::*THE-CLASS-BIT-VECTOR* PCL::ORIGINAL SYSTEM::TP6
    PCL::|CACHE SLOT10| PCL::|__si::MAKE-N-N|
-   PCL::|(SETF SLOT-DEFINITION-READERS)|
    PCL::|(SETF SLOT-DEFINITION-WRITERS)|
-   PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
-   PCL::*THE-CLASS-DOCUMENTATION-MIXIN* PCL::*THE-CLASS-PLIST-MIXIN*
+   PCL::|(SETF SLOT-DEFINITION-READERS)|
    PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
+   PCL::*THE-CLASS-PLIST-MIXIN* PCL::*THE-CLASS-DOCUMENTATION-MIXIN*
+   PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
    PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::REBOUND?
    PCL::*THE-WRAPPER-OF-FUNCTION* PCL::WRAPPER1
-   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)|
+   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)|
    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-DEFINITION-LOCATION)|
-   PCL::|(SETF SLOT-DEFINITION-READER-FUNCTION)|
-   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-ACCESSOR-FUNCTION)|
    PCL::|(SETF SLOT-DEFINITION-INITFUNCTION)|
-   PCL::|(SETF SLOT-ACCESSOR-FUNCTION)| PCL::CONSTRUCTORS
+   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-READER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-LOCATION)| PCL::CONSTRUCTORS
    PCL::*THE-CLASS-RATIO* PCL::MAKE-CHECKING-DFUN PCL::CLASS-NAMES
-   PCL::|(SETF SLOT-DEFINITION-CLASS)|
    PCL::|(SETF SLOT-VALUE-USING-CLASS)|
+   PCL::|(SETF SLOT-DEFINITION-CLASS)|
    PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
    PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OBJECT)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)| PCL::AFTER
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)| PCL::AFTER
    PCL::RESET-PACKAGE PCL::CHECKING-MISS PCL::LINE
-   PCL::*THE-WRAPPER-OF-STREAM* PCL::*THE-WRAPPER-OF-FILE-STREAM*
-   PCL::*THE-WRAPPER-OF-BROADCAST-STREAM*
-   PCL::*THE-WRAPPER-OF-CONCATENATED-STREAM*
-   PCL::*THE-WRAPPER-OF-STRING-STREAM*
-   PCL::*THE-WRAPPER-OF-TWO-WAY-STREAM*
+   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM*
    PCL::*THE-WRAPPER-OF-ECHO-STREAM*
-   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM* PCL::CPL-ERROR
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::*THE-WRAPPER-OF-TWO-WAY-STREAM*
+   PCL::*THE-WRAPPER-OF-STRING-STREAM*
+   PCL::*THE-WRAPPER-OF-CONCATENATED-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::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
    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
@@ -2986,39 +2987,40 @@
    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 FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
-   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)|
+   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)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
    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 METHOD-CLASS)|
+   SYSTEM::TP5 PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)| PCL::*BOOT-STATE*
-   PCL::*SGF-DFUN-STATE-INDEX* PCL::CACHE-OWNER PCL::RESET-PCL-PACKAGE
-   PCL::NEW-KEYS PCL::POSSIBLY-APPLICABLE COMMON-LISP::EXPT
-   PCL::LIST-LARGE-CACHE PCL::.METHOD-COMBINATION.
+   PCL::|(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::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-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|
+   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|
    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
@@ -3028,19 +3030,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::NO-METHODS PCL::DO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
+   PCL::DO-METHODS PCL::NO-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-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*
+   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*
    CSTRUCT::C-SET-READTABLE-CASE PCL::.CACHE.
    PCL::ACCESSOR-SET-SLOT-VALUE
    PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
@@ -3050,42 +3052,41 @@
    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 NAME)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)|
    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::|(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::*THE-CLASS-STANDARD-METHOD* PCL::*THE-CLASS-METHOD*
-   PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD* COMMON-LISP::CHAR-DOWNCASE
+   PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
+   PCL::*THE-CLASS-STANDARD-BOUNDP-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::FMC-FUNCALL PCL::EMF-FUNCALL SYSTEM::TP3 PCL::SMC
-   PCL::PV-TABLE-SLOT-NAME-LISTS
-   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN
+   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::MAKE-FINAL-N-N-ACCESSOR-DFUN
-   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN PCL::MAKE-FINAL-CACHING-DFUN
-   PCL::MAKE-FINAL-DISPATCH-DFUN PCL::MAKE-FINAL-CHECKING-DFUN
-   PCL::MAKE-FINAL-ACCESSOR-DFUN PCL::MODULE-COMP-ENV
-   PCL::MODULE-LOAD-ENV PCL::LOAD-DEFMETHOD-INTERNAL PCL::SETQS
+   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN PCL::MODULE-LOAD-ENV
+   PCL::MODULE-COMP-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-READTABLE*
-   PCL::*THE-CLASS-HASH-TABLE* COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS
+   PCL::SORT-METHODS PCL::*THE-CLASS-HASH-TABLE*
+   PCL::*THE-CLASS-READTABLE* COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS
    PCL::COMPILE-FILTER PCL::NEW-ICUI CSTRUCT::C-T-MDIM
    PCL::PV-TABLE-PV-SIZE PCL::ALLOCATE COMMON-LISP::SYMBOL-PACKAGE
    PCL::MAKE-PROGN PCL::CONSTANT-VALUE PCL::TO-CACHE PCL::LMF-PARAMS
    PCL::*EQ-CASE-TABLE-LIMIT* PCL::COPY-INITIALIZE-INFO PCL::TESTS
    PCL::REAL-METHOD-COMBINATION-ERROR CSTRUCT::C-HASHTABLE-CACHE
-   PCL::GET-VAL PCL::SET-VAL CSTRUCT::C-PATHNAME-DEVICE
+   PCL::SET-VAL PCL::GET-VAL CSTRUCT::C-PATHNAME-DEVICE
    COMMON-LISP::SVREF PCL::ACCESSOR-DFUN-INFO-CACHE PCL::FIX
    PCL::CLASS-CONSTRUCTORS PCL::PVREF PCL::INVOKE-FAST-METHOD-CALL
    PCL::{METHOD-QUALIFIER}* PCL::FORMAT-ARGS
    PCL::FINISH-PUSHING-INITARGS PCL::FORMAT-CYCLE-REASONS
-   PCL::STD-MI-METH PCL::STD-SI-METH PCL::STD-II-METH
+   PCL::STD-II-METH PCL::STD-SI-METH PCL::STD-MI-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
@@ -3128,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-DFUN-INTERNAL PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL
+   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-FINAL-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 CLASS DIRECT-SUPERCLASSES)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
    PCL::|(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| PCL::NTYPE
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)| 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
@@ -3151,22 +3152,22 @@
    PCL::REQUIRED
    PCL::|(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
    PCL::*UMI-COMPLETE-CLASSES*
-   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::|(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::UNCOMPILED COMMON-LISP::STRING-UPCASE
    COMMON-LISP::STRING-DOWNCASE CSTRUCT::C-T-MHASFILLP
    PCL::GF-DFUN-INFO PCL::POP-INTO
@@ -3180,127 +3181,129 @@
    COMMON-LISP::MAP-INTO PCL::EARLY-GF-METHODS
    PCL::MAKE-STRUCTURE-OBJECT PCL::LIST-PV
    COMMON-LISP::ARITHMETIC-ERROR PCL::GET-FUNCTION-GENERATOR
-   PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION ARGUMENTS-LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
-   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)|
+   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)|
    CSTRUCT::C-SET-STREAM-OBJECT1 PCL::FORWARD-CLASS PCL::SAUT-NOT-EQL
    COMMON-LISP::PROVIDE PCL::SLOT-REGS
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)| PCL::BY
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-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-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::|(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFORM)|
    PCL::WITH-EQ-HASH-TABLE
-   PCL::|(FAST-READER-METHOD EQL-SPECIALIZER OBJECT)|
-   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 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 STANDARD-METHOD-COMBINATION 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 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 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 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 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::|(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::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 STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS)|
    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-READER-FUNCTION
+   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-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::SLOT-DEFINITION-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::*KEYWORD-PACKAGE*
-   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
    PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::WHY PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
+   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION 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-NAME PCL::SLOT-NAMES
+   PCL::RECOMP-REASONS PCL::SLOT-NAMES PCL::SLOT-NAME
    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)|
@@ -3313,9 +3316,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 SYSTEM::SIZE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SIZE)|
    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 MASK)| PCL::CHECK-MEMBER
    PCL::COPY-INITIAL-DISPATCH PCL::MAKE-METHOD-FUNCTION
    PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-ENTRY-FN
@@ -3334,19 +3337,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 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)|
+   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)|
    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
@@ -3360,7 +3363,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-POSITIONS PCL::SPECIALIZED-ARGUMENT-POSITIONS
+   PCL::SPECIALIZED-ARGUMENT-POSITIONS PCL::SPECIALIZED-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)|
@@ -3403,11 +3406,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-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
+   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
    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
@@ -3418,11 +3421,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::.FUNCTION. PCL::CFUNCTION
-   PCL::TFUNCTION PCL::OFUNCTION PCL::DEFAULT-INITARGS-1
+   CSTRUCT::C-PACKAGE-EXTERNAL_SIZE PCL::OFUNCTION PCL::TFUNCTION
+   PCL::CFUNCTION PCL::.FUNCTION. PCL::DEFAULT-INITARGS-1
    COMMON-LISP::DEFINE-COMPILER-MACRO PCL::ARG-INFO
    PCL::|ARG-INFO SLOT0| PCL::FAST-METHOD-CALL-P
-   PCL::|(WRITER OPTIONS)| PCL::|(WRITER METHODS)| COMMON-LISP::BOOLEAN
+   PCL::|(WRITER METHODS)| PCL::|(WRITER OPTIONS)| 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
@@ -3430,50 +3433,49 @@
    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-SUPERCLASSES)|
-   PCL::|(WRITER DIRECT-SUBCLASSES)| COMMON-LISP::MAKE-ARRAY
+   PCL::|(WRITER DIRECT-SUBCLASSES)|
+   PCL::|(WRITER DIRECT-SUPERCLASSES)| 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::STD-METHOD
-   PCL::STR-METHOD
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
+   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::|(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VECTOR)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
    PCL::GET-GENERIC-FUNCTION-INFO COMMON-LISP::DELETE-DUPLICATES
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITARGS)|
-   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::|(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::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 METHOD-COMBINATION)|
+   PCL::|(WRITER INTERNAL-WRITER-FUNCTION)|
    PCL::|(WRITER INTERNAL-READER-FUNCTION)|
-   PCL::|(WRITER INTERNAL-WRITER-FUNCTION)| PCL::GET-METHOD
-   PCL::NEW-METHOD PCL::|COMPILER::FN SLOT2|
+   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::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-ONE-INDEX-DFUN-INFO| PCL::|__si::MAKE-DFUN-INFO|
-   PCL::|__si::MAKE-ARG-INFO| PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|
+   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| PCL::|__si::MAKE-ARG-INFO|
+   PCL::|__si::MAKE-DFUN-INFO| PCL::|__si::MAKE-ONE-INDEX-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)|
@@ -3486,12 +3488,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::FIN PCL::PROTO-GF
+   COMMON-LISP::NAMESTRING PCL::PROTO-GF PCL::FIN
    PCL::DEFINE-GF-PREDICATE CSTRUCT::C-FLOAT-DOUBLE-==
    PCL::|PCL::PLIST-MIXIN class predicate| PCL::AROUND
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
-   PCL::|(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
    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::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,47 +1,249 @@
 
 (PROCLAIM
  '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|)) 
+(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) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
+   PCL::SYMBOL-LESSP)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
     (VALUES
-     &OPTIONAL
+     &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))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-DEFAULT-ONLY)) 
+      (OR
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-CACHING-DFUN)) 
 (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)) 
+   (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)) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
+   (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 ((STRUCTURE PCL::TWO-CLASS)) (T)) PCL::TWO-CLASS-CACHE
+   PCL::TWO-CLASS-INDEX PCL::TWO-CLASS-WRAPPER1 PCL::TWO-CLASS-WRAPPER0
+   PCL::TWO-CLASS-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T)
+     (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) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES
+     (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::REAL-MAKE-METHOD-LAMBDA)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::OPTIMIZE-GF-CALL)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::INITIAL-DISPATCH))
+    (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::COPY-INITIAL-DISPATCH)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T) (INTEGER 0 9223372036854775807))
-    (STRUCTURE PCL::CACHE))
-   PCL::GET-CACHE)) 
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::FILL-CACHE-FROM-CACHE-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::PARSE-QUALIFIER-PATTERN)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T) (T) (T))
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
+   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (SYSTEM:PROPER-CONS (T) (T)) (T)))
+   PCL::SPLIT-DECLARATIONS-MOVING-IGNORES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL PCL::ENSURE-CLASS-VALUES)) 
+(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)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   WALKER::VARIABLE-SYMBOL-MACRO-P PCL::REMTAIL PCL::%SET-CCLOSURE
+   PCL::MAKE-DLAP-LAMBDA-LIST PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST
+   PCL::MAKE-DFUN-LAMBDA-LIST PCL::MAKE-PLIST PCL::DEFAULT-INITARGS-1
+   PCL::MEC-ALL-CLASSES PCL::DESTRUCTURE-INTERNAL
+   PCL::CLASS-CAN-PRECEDE-P WALKER:VARIABLE-LEXICAL-P
+   PCL::MEC-ALL-CLASS-LISTS PCL::NET-CONSTANT-CONVERTER
+   PCL::MEMF-CONSTANT-CONVERTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL))
+   PCL::|__si::MAKE-INITIAL|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::CPD-COUNT)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-NOT)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION)) 
+(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) &REST T)
     (VALUES
+     &OPTIONAL
      (OR
-      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
-     (T)
+      (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))
+    (VALUES
+     (INTEGER 0 268435455) (T)
      (OR
       (OR
        (OR
@@ -64,8 +266,208 @@
         (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))))
+     (INTEGER 0 268435455) (STRUCTURE PCL::ARG-INFO)))
+   PCL::GET-GENERIC-FUNCTION-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (VALUES (T) (T)))
+   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
+(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)) 
+(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)) 
+(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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
+   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
+(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)) 
+(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 ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
+(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)) 
+(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
+    ((T) (T) (T))
+    (OR
+     (OR
+      (OR
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::SORT-APPLICABLE-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -75,27 +477,344 @@
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((STRUCTURE PCL::FAST-METHOD-CALL))
+    (OR
+     (OR
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::FAST-METHOD-CALL-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
+   ITERATE::SEQUENCE-ACCESSOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     &REST T)
     (VALUES
+     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MUTATE-SLOTS-AND-CALLS PCL::SLOT-NAME-LISTS-FROM-SLOTS)) 
+   PCL::PARSE-SPECIALIZED-LAMBDA-LIST)) 
+(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)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
-    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::SAUT-AND)) 
+    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
+     (T))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (NULL) (T)) (T))
-   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) (T) &REST T)
     (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
+     (T)
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))))
+   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (VALUES &REST T)) SYSTEM::CLASSP
+   MAKE-INSTANCES-OBSOLETE METHOD-QUALIFIERS PCL:METHOD-LAMBDA-LIST
+   FUNCTION-KEYWORDS PCL:SPECIALIZER-DIRECT-METHODS
+   PCL:METHOD-SPECIALIZERS PCL:SLOT-DEFINITION-ALLOCATION
+   PCL:COMPUTE-CLASS-PRECEDENCE-LIST PCL:CLASS-FINALIZED-P
+   PCL:COMPUTE-DISCRIMINATING-FUNCTION PCL:CLASS-DEFAULT-INITARGS
+   PCL:CLASS-DIRECT-SLOTS PCL:GENERIC-FUNCTION-LAMBDA-LIST
+   PCL:FINALIZE-INHERITANCE PCL:COMPUTE-SLOTS PCL:CLASS-SLOTS
+   PCL:METHOD-FUNCTION PCL:CLASS-PROTOTYPE
+   PCL:CLASS-DIRECT-DEFAULT-INITARGS PCL::INTERN-FUNCTION-NAME
+   PCL::COMPILE-IIS-FUNCTIONS PCL::|ARG-INFO SLOT10| PCL::MAKE-KEYWORD
+   PCL::|PV-TABLE SLOT3| PCL::|CHECKING SLOT1| PCL::|PV-TABLE SLOT2|
+   PCL::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 CLASS-PROTOTYPE-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL EQL-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::|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|
+   PCL::|SYSTEM:S-DATA SLOT4| PCL::|SYSTEM:S-DATA SLOT3|
+   PCL::COMPUTE-DEFAULT-INITARGS PCL::|SYSTEM:S-DATA SLOT2|
+   PCL::|SYSTEM:S-DATA SLOT1| PCL::STANDARD-GENERIC-FUNCTION-P
+   PCL::STANDARD-READER-METHOD-P PCL::STANDARD-METHOD-P
+   PCL::|SYSTEM:S-DATA SLOT0| PCL::STANDARD-ACCESSOR-METHOD-P
+   PCL::DFUN-ARG-SYMBOL PCL::CLASS-SLOT-CELLS PCL::SLOT-BOUNDP-SYMBOL
+   PCL::|METHOD-CALL SLOT1| PCL::|METHOD-CALL SLOT0| PCL::METHOD-P
+   PCL::GF-FAST-METHOD-FUNCTION-P PCL::FORWARD-REFERENCED-CLASS-P
+   PCL::|INITIALIZE-INFO SLOT9| PCL::|INITIALIZE-INFO SLOT8|
+   PCL::|INITIALIZE-INFO SLOT7| PCL::|INITIALIZE-INFO SLOT6|
+   PCL::|INITIALIZE-INFO SLOT5| PCL::|INITIALIZE-INFO SLOT4|
+   PCL::|INITIALIZE-INFO SLOT3| PCL::|INITIALIZE-INFO SLOT2|
+   PCL::|INITIALIZE-INFO SLOT1| PCL::|INITIALIZE-INFO SLOT0|
+   PCL::GENERIC-FUNCTION-P PCL::GENERIC-FUNCTION-NAME-P
+   PCL::|CACHE SLOT11| PCL::|CACHE SLOT10|
+   PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::MAKE-CLASS-PREDICATE-NAME
+   PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS PCL::CLASS-CONSTRUCTORS
+   PCL::|ARG-INFO SLOT9| PCL::|ARG-INFO SLOT8| PCL::|ARG-INFO SLOT7|
+   PCL::|ARG-INFO SLOT6| PCL::|ARG-INFO SLOT5| PCL::|ARG-INFO SLOT4|
+   PCL::|COMPILER::FN SLOT8| PCL::|ARG-INFO SLOT3|
+   PCL::SPECIALIZER-METHOD-TABLE PCL::|COMPILER::FN SLOT7|
+   PCL::|ARG-INFO SLOT2| PCL::|COMPILER::FN SLOT6|
+   PCL::|ARG-INFO SLOT1| PCL::SHORT-METHOD-COMBINATION-P
+   PCL::|COMPILER::FN SLOT5| PCL::|ARG-INFO SLOT0|
+   PCL::|COMPILER::FN SLOT4| PCL::|COMPILER::FN SLOT3|
+   PCL::|COMPILER::FN SLOT2| PCL::|COMPILER::FN SLOT1|
+   PCL::SLOT-CLASS-P PCL::|COMPILER::FN SLOT0|
+   PCL::FUNCALLABLE-STANDARD-CLASS-P
+   PCL::|TYPE-PREDICATE COMMON-LISP STRUCTURE-CLASS|
+   PCL::|TYPE-PREDICATE COMMON-LISP BUILT-IN-CLASS|
+   PCL::|TYPE-PREDICATE PCL FORWARD-REFERENCED-CLASS|
+   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-CLASS|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-CLASS|
+   PCL::|TYPE-PREDICATE PCL STD-CLASS|
+   PCL::|TYPE-PREDICATE PCL SLOT-CLASS|
+   PCL::|TYPE-PREDICATE PCL PCL-CLASS|
+   PCL::|TYPE-PREDICATE COMMON-LISP CLASS|
+   PCL::|TYPE-PREDICATE PCL SPECIALIZER-WITH-OBJECT|
+   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-OBJECT|
+   PCL::|TYPE-PREDICATE PCL METAOBJECT|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-OBJECT|
+   PCL::|TYPE-PREDICATE PCL SHORT-METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE PCL LONG-METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE COMMON-LISP METHOD-COMBINATION|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-GENERIC-FUNCTION|
+   PCL::|TYPE-PREDICATE COMMON-LISP GENERIC-FUNCTION|
+   PCL::|TYPE-PREDICATE PCL STRUCTURE-EFFECTIVE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STRUCTURE-DIRECT-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-EFFECTIVE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-DIRECT-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL EFFECTIVE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL DIRECT-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STRUCTURE-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL STANDARD-SLOT-DEFINITION|
+   PCL::|TYPE-PREDICATE PCL SLOT-DEFINITION| PCL::GET-DISPATCH-FUNCTION
+   PCL::|FAST-METHOD-CALL SLOT3| PCL::METHOD-COMBINATION-P
+   PCL::|FAST-METHOD-CALL SLOT2|
+   PCL::INITIALIZE-INTERNAL-SLOT-FUNCTIONS
+   PCL::|FAST-METHOD-CALL SLOT1| PCL::GF-LAMBDA-LIST
+   PCL::|FAST-METHOD-CALL SLOT0| PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::|TYPE-PREDICATE PCL TRACED-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-BOUNDP-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-WRITER-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-READER-METHOD|
+   PCL::|TYPE-PREDICATE PCL STANDARD-ACCESSOR-METHOD|
+   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-METHOD|
+   PCL::|TYPE-PREDICATE COMMON-LISP METHOD| PCL::|SYSTEM:S-DATA SLOT17|
+   PCL::|SYSTEM:S-DATA SLOT16| PCL::|SYSTEM:S-DATA SLOT15|
+   PCL::|SYSTEM:S-DATA SLOT14| PCL::|SYSTEM:S-DATA SLOT13|
+   PCL::|SYSTEM:S-DATA SLOT12| PCL::CLASSP PCL::|SYSTEM:S-DATA SLOT11|
+   PCL::|SYSTEM:S-DATA SLOT10| PCL::|ONE-INDEX-DFUN-INFO SLOT2|
+   PCL::CLASS-PREDICATE-NAME PCL::|TWO-CLASS SLOT4| PCL::|CACHE SLOT9|
+   PCL::GENERIC-FUNCTION-PRETTY-ARGLIST PCL::|CACHE SLOT8|
+   PCL::|CACHE SLOT7| PCL::|CACHE SLOT6| PCL::|CACHE SLOT5|
+   PCL::|CACHE SLOT4| PCL::|CACHE SLOT3| PCL::ACCESSOR-METHOD-CLASS
+   PCL::|CACHE SLOT2| PCL::|CACHE SLOT1| PCL::|CACHE SLOT0|
+   PCL::|ONE-CLASS SLOT3| PCL::METHOD-PRETTY-ARGLIST
+   PCL::|INITIALIZE-INFO SLOT13| PCL::KEYWORD-SPEC-NAME
+   PCL::|INITIALIZE-INFO SLOT12|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT3|
+   PCL::|INITIALIZE-INFO SLOT11|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT2|
+   PCL::|INITIALIZE-INFO SLOT10|
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT1| PCL::STRUCTURE-CLASS-P
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT0| PCL::|MODULE SLOT4|
+   PCL::SLOTS-FETCHER PCL::|MODULE SLOT3| PCL::CLASS-EQ-SPECIALIZER-P
+   PCL::|MODULE SLOT2| PCL::SPECIALIZER-CLASS PCL::|MODULE SLOT1|
+   PCL::ACCESSOR-METHOD-SLOT-NAME PCL::LONG-METHOD-COMBINATION-P
+   PCL::|MODULE SLOT0| PCL::METHOD-PROTOTYPE-FOR-GF
+   PCL::EXACT-CLASS-SPECIALIZER-P PCL::SPECIALIZERP
+   PCL::SLOT-VECTOR-SYMBOL PCL::SLOT-READER-SYMBOL
+   PCL::SPECIALIZER-FROM-TYPE PCL::INSURE-CACHING-DFUN
+   PCL::EQL-SPECIALIZER-P PCL::|ACCESSOR-DFUN-INFO SLOT1|
+   PCL::|FAST-INSTANCE-BOUNDP SLOT0|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
+   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-DLAP)) 
+(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
+    ((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)) (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 NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+(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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
+   PCL::CONSTANT-VALUE-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
+   PCL::MAKE-N-N-ACCESSOR-DFUN)) 
+(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 ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
+   PCL::COPY-DISPATCH)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::TWO-CLASS))
+   PCL::|__si::MAKE-TWO-CLASS|)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-EMF-CALL-METHOD
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
+   PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 PCL::OPTIMIZE-ACCESSOR-CALL
+   PCL::REAL-MAKE-METHOD-INITARGS-FORM)) 
+(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 (&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) &REST T)
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
+   PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::DISPATCH))
+   PCL::|__si::MAKE-DISPATCH|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CACHE))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::CACHE-OVERFLOW)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::INITIALIZE-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR
+      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
+     (T)
      (OR
       (OR
        (OR
@@ -119,182 +838,135 @@
         (SYSTEM::NON-SIMPLE-ARRAY T *)
         (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
       (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
-   PCL::DESTRUCTURE)) 
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (T)) SETF::|PCL::INITIALIZE-INFO SLOT5|
-   SETF::|PCL::SYSTEM:S-DATA SLOT3| SETF::|PCL::GDEFINITION|
-   SETF::|PCL::ONE-INDEX-DFUN-INFO SLOT2| SETF::|PCL::ARG-INFO SLOT5|
-   SETF::|PCL::FAST-METHOD-CALL SLOT2|
-   SETF::|PCL::CLASS-DEFSTRUCT-CONSTRUCTOR| SETF::|PCL::PV-TABLE SLOT1|
-   SETF::|PCL::MODULE SLOT2| SETF::|PCL::CACHE SLOT7|
-   SETF::|PCL::COMPILER::FN SLOT2| SETF::|PCL::SYSTEM:S-DATA SLOT13|
-   SETF::|PCL::SLOT-DEFINITION-LOCATION|
-   SETF::|PCL::SLOT-DEFINITION-READER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-WRITER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-BOUNDP-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION|
-   SETF::|PCL::SLOT-DEFINITION-ALLOCATION|
-   SETF::|PCL::SLOT-DEFINITION-INITFUNCTION|
-   SETF::|PCL::INITIALIZE-INFO SLOT3| SETF::|PCL::SYSTEM:S-DATA SLOT1|
-   SETF::|PCL::GF-PRETTY-ARGLIST| SETF::|PCL::ARG-INFO SLOT3|
-   SETF::|PCL::FAST-METHOD-CALL SLOT0|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT3|
-   SETF::|PCL::INITIALIZE-INFO SLOT13| SETF::|PCL::MODULE SLOT0|
-   SETF::|PCL::CACHE SLOT5| SETF::|PCL::COMPILER::FN SLOT0|
-   SETF::|PCL::SYSTEM:S-DATA SLOT11|
-   SETF::|PCL::SLOT-DEFINITION-INITFORM|
-   SETF::|PCL::INITIALIZE-INFO SLOT1| SETF::|PCL::ARG-INFO SLOT1|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT1|
-   SETF::|PCL::OBJECT-PLIST| SETF::|PCL::SYSTEM:S-DATA SLOT8|
-   SETF::|PCL::INITIALIZE-INFO SLOT11| SETF::|PCL::CACHE SLOT3|
-   SETF::|PCL::GENERIC-FUNCTION-METHOD-CLASS|
-   SETF::|PCL::ACCESSOR-DFUN-INFO SLOT1|
-   SETF::|PCL::FIND-CLASS-PREDICATE| SETF::|PCL::GENERIC-FUNCTION-NAME|
-   SETF::|PCL::COMPILER::FN SLOT7| SETF::|PCL::METHOD-CALL SLOT1|
-   SETF::|PCL::FAST-INSTANCE-BOUNDP SLOT0|
-   SETF::|PCL::INITIALIZE-INFO SLOT8| SETF::|PCL::SYSTEM:S-DATA SLOT6|
-   SETF::|PCL::CACHE SLOT1| SETF::|PCL::ARG-INFO SLOT8|
-   SETF::|PCL::SLOT-DEFINITION-TYPE|
-   SETF::|PCL::SLOT-DEFINITION-READERS|
-   SETF::|PCL::SLOT-DEFINITION-WRITERS|
-   SETF::|PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL|
-   SETF::|PCL::COMPILER::FN SLOT5| SETF::|PCL::SYSTEM:S-DATA SLOT16|
-   SETF::|PCL::CACHE SLOT11| SETF::|PCL::CHECKING SLOT1|
-   SETF::|PCL::INITIALIZE-INFO SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT4|
-   SETF::|PCL::ARG-INFO SLOT6| SETF::|PCL::FAST-METHOD-CALL SLOT3|
-   SETF::|PCL::PV-TABLE SLOT2| SETF::|PCL::MODULE SLOT3|
-   SETF::|PCL::CACHE SLOT8| SETF::|PCL::COMPILER::FN SLOT3|
-   SETF::|PCL::SYSTEM:S-DATA SLOT14| SETF::|PCL::INITIALIZE-INFO SLOT4|
-   SETF::|PCL::SYSTEM:S-DATA SLOT2| SETF::|PCL::TWO-CLASS SLOT4|
-   SETF::|PCL::CLASS-DIRECT-SLOTS| SETF::|PCL::CLASS-SLOTS|
-   SETF::|PCL::ONE-CLASS SLOT3| SETF::|PCL::METHOD-GENERIC-FUNCTION|
-   SETF::|PCL::ARG-INFO SLOT4| SETF::|PCL::FAST-METHOD-CALL SLOT1|
-   SETF::|COMMON-LISP::CLASS-NAME|
-   SETF::|PCL::GENERIC-FUNCTION-METHOD-COMBINATION|
-   SETF::|PCL::PV-TABLE SLOT0| SETF::|PCL::MODULE SLOT1|
-   SETF::|PCL::CACHE SLOT6| SETF::|PCL::COMPILER::FN SLOT1|
-   SETF::|PCL::SYSTEM:S-DATA SLOT12| SETF::|PCL::CLASS-DEFSTRUCT-FORM|
-   SETF::|PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST|
-   SETF::|PCL::INITIALIZE-INFO SLOT2|
-   SETF::|PCL::SLOT-DEFINITION-INITARGS|
-   SETF::|PCL::SYSTEM:S-DATA SLOT0| SETF::|PCL::ARG-INFO SLOT2|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT2|
-   SETF::|PCL::SYSTEM:S-DATA SLOT9| SETF::|PCL::INITIALIZE-INFO SLOT12|
-   SETF::|PCL::CACHE SLOT4| SETF::|PCL::METHOD-FUNCTION-PLIST|
-   SETF::|PCL::SYSTEM:S-DATA SLOT10| SETF::|PCL::INITIALIZE-INFO SLOT0|
-   SETF::|PCL::SLOT-DEFINITION-CLASS| SETF::|PCL::COMPILER::FN SLOT8|
-   SETF::|PCL::ARG-INFO SLOT0| SETF::|PCL::SLOT-DEFINITION-NAME|
-   SETF::|PCL::INITIALIZE-INFO SLOT9|
-   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT0|
-   SETF::|PCL::SYSTEM:S-DATA SLOT7| SETF::|PCL::INITIALIZE-INFO SLOT10|
-   SETF::|PCL::CACHE SLOT2| SETF::|PCL::ARG-INFO SLOT9|
-   SETF::|PCL::ARG-INFO SLOT10|
-   SETF::|PCL::GENERIC-FUNCTION-INITIAL-METHODS|
-   SETF::|PCL::GENERIC-FUNCTION-METHODS|
-   SETF::|PCL::COMPILER::FN SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT17|
-   SETF::|PCL::METHOD-CALL SLOT0| SETF::|PCL::INITIALIZE-INFO SLOT7|
-   SETF::|PCL::SYSTEM:S-DATA SLOT5| SETF::|PCL::CACHE SLOT0|
-   SETF::|PCL::ARG-INFO SLOT7| SETF::|PCL::CLASS-INITIALIZE-INFO|
-   SETF::|PCL::GF-DFUN-STATE| SETF::|PCL::PV-TABLE SLOT3|
-   SETF::|PCL::MODULE SLOT4| SETF::|PCL::CACHE SLOT9|
-   SETF::|PCL::COMPILER::FN SLOT4| SETF::|PCL::SYSTEM:S-DATA SLOT15|
-   SETF::|PCL::CACHE SLOT10| SETF::|PCL::DFUN-INFO SLOT0|
-   WALKER::ENVIRONMENT-FUNCTION WALKER::ENVIRONMENT-MACRO
-   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot WRITER| 
-   SLOT-ACCESSOR-NAME::|PCL SLOTS slot WRITER|
-   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot WRITER|
-   ITERATE::MV-SETQ SLOT-BOUNDP
-   PCL:FUNCALLABLE-STANDARD-INSTANCE-ACCESS SLOT-MAKUNBOUND
-   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::VARIABLE-CLASS
-   PCL::COMPUTE-APPLICABLE-KEYWORDS PCL::COMPUTE-CONSTANTS
-   PCL::FDEFINE-CAREFULLY PCL::SET-INITIAL-METHODS
-   PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P PCL::PROCLAIM-DEFMETHOD
-   PCL::DESCRIBE-PACKAGE PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER
-   PCL::%CCLOSURE-ENV-NTHCDR PCL::MAP-PV-TABLE-REFERENCES-OF
-   PCL::AUGMENT-TYPE PCL::GET-KEY-ARG-TAIL PCL::VALUE-FOR-CACHING
-   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::REAL-REMOVE-METHOD
-   PCL::SET-METHODS PCL::SET-STRUCTURE-SVUC-METHOD PCL::COMPUTE-PV
-   PCL::SWAP-WRAPPERS-AND-SLOTS PCL::REDIRECT-EARLY-FUNCTION-INTERNAL
-   WALKER:VARIABLE-SPECIAL-P PCL::LEGAL-LAMBDA-LIST-P
-   PCL::FIND-STANDARD-II-METHOD PCL::SLOT-BOUNDP-NORMAL
-   PCL::SET-STANDARD-SVUC-METHOD PCL::PROCLAIM-DEFGENERIC
-   PCL::SET-WRAPPER PCL::ADD-FORMS PCL::MAKE-CLASS-PREDICATE
-   PCL::UPDATE-INITS PCL::REDEFINE-FUNCTION
-   PCL::SET-FUNCTION-PRETTY-ARGLIST PCL::PRINTING-RANDOM-THING-INTERNAL
-   PCL::SLOT-UNBOUND-INTERNAL PCL::PLIST-VALUE PCL::MAKE-CDXR
-   PCL::FIND-SLOT-DEFINITION PCL::SET-FUNCTION-NAME)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
 (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)) 
+   (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)) 
 (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)) 
+    ((STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::COPY-ACCESSOR-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::LIST-DFUN)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (NOT (MEMBER NIL))) PCL::PV-TABLE-LOOKUP)) 
+    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
-   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
+   (FUNCTION ((T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::FUN-TO-FUNCALLABLE-INSTANCE)) 
 (PROCLAIM
- '(FTYPE (FUNCTION NIL (STRUCTURE PCL::ARG-INFO)) PCL::MAKE-ARG-INFO)) 
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 7)) PCL::CACHE-FIELD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES &OPTIONAL (T) (T) (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
-   PCL::CACHE-MISS-VALUES)) 
+   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
+   PCL::COPY-ARG-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (INTEGER 0 9223372036854775807) &REST T)
-    (STRUCTURE PCL::CACHE))
-   PCL::GET-CACHE-FROM-CACHE)) 
+   (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)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
+   (FUNCTION ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
+   PCL::COPY-CACHING)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
+    ((T) (T) (T))
     (VALUES
-     &OPTIONAL (T) (T)
+     &OPTIONAL
      (OR
-      (OR
-       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)
-       (STRUCTURE PCL::CHECKING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::NO-METHODS))
-      (MEMBER NIL))))
-   PCL::MAKE-FINAL-DFUN-INTERNAL)) 
+      (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
-    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::COPY-CONSTANT-VALUE)) 
+   (FUNCTION ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION (&REST T) (VALUES &REST T))
@@ -628,27 +1300,27 @@
    PCL:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER INVALID-METHOD-ERROR
    METHOD-COMBINATION-ERROR PCL::REMOVE-NAMED-METHOD
    PCL::|PCL::TRACED-METHOD class predicate| PCL::USE-PACKAGE-PCL
-   PCL::|COMMON-LISP::NULL class predicate|
-   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
-   PCL::|COMMON-LISP::SYMBOL class predicate|
-   PCL::|COMMON-LISP::CHARACTER class predicate|
-   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
-   PCL::|COMMON-LISP::STRING class predicate|
-   PCL::|COMMON-LISP::VECTOR class predicate|
-   PCL::|COMMON-LISP::ARRAY class predicate|
-   PCL::|COMMON-LISP::STREAM class predicate|
-   PCL::|COMMON-LISP::FILE-STREAM class predicate|
-   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
-   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
-   PCL::|COMMON-LISP::STRING-STREAM class predicate|
-   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
-   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
-   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
-   PCL::|COMMON-LISP::HASH-TABLE class predicate|
-   PCL::|COMMON-LISP::PACKAGE class predicate|
-   PCL::|COMMON-LISP::READTABLE class predicate|
-   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
    PCL::|COMMON-LISP::PATHNAME class predicate|
+   PCL::|COMMON-LISP::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::NULL class predicate|
    PCL::|COMMON-LISP::CONS class predicate|
    PCL::|COMMON-LISP::LIST class predicate|
    PCL::|COMMON-LISP::SEQUENCE class predicate|
@@ -708,306 +1380,143 @@
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T) (T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MEMF-CODE-CONVERTER)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::KEY-NAMES)) 
+    ((T))
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (NULL)))
+   PCL::EMIT-ONE-CLASS-WRITER PCL::EMIT-ONE-CLASS-READER
+   PCL::EMIT-TWO-CLASS-WRITER PCL::EMIT-TWO-CLASS-READER
+   PCL::EMIT-ONE-INDEX-WRITERS PCL::EMIT-ONE-INDEX-READERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 7)) PCL::CACHE-FIELD)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::COPY-ONE-INDEX)) 
 (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)) 
+   (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
-    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::CPD-COUNT)) 
+   (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) (T))
-    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
-   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (NULL)) PCL::CHECK-APPLICABLE-KEYWORDS
-   PCL::ADD-SLOT-ACCESSORS PCL::REMOVE-SLOT-ACCESSORS
-   PCL::ADD-DIRECT-SUBCLASSES PCL::REMOVE-DIRECT-SUBCLASSES
-   PCL::METHOD-FUNCTION-RETURNING-NIL PCL::UPDATE-ALL-PV-TABLE-CACHES
-   PCL::UPDATE-CPL PCL::UPDATE-SLOTS PCL::UPDATE-CLASS
-   PCL::UPDATE-STD-OR-STR-METHODS)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
+   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
 (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)) 
+   (FUNCTION ((T) (T) (T)) (NULL)) PCL::PRINT-CACHE
+   PCL::NOTE-PV-TABLE-REFERENCE PCL::FIX-SLOT-ACCESSORS
+   PCL::CHECK-METHOD-ARG-INFO
+   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
+   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS*)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T))
+    ((T) (T) (T) (T) (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
-    ((OR
+     (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::PARSE-SPECIALIZERS)) 
-(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 ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
-   PCL::COPY-PV-TABLE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-DLAP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (T)) SYSTEM::CLASS-PRECEDENCE-LIST SYSTEM::CLASSP
-   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::WRAPPER-FETCHER PCL::EARLY-CLASS-PRECEDENCE-LIST-SYMBOL
-   PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST
-   PCL::STANDARD-WRITER-METHOD-P PCL::RAW-INSTANCE-ALLOCATOR
-   PCL::STANDARD-BOUNDP-METHOD-P PCL::METHOD-FUNCTION-METHOD
-   PCL::FORCE-CACHE-FLUSHES PCL::STANDARD-CLASS-P
-   PCL::EARLY-CLASS-NAME-OF PCL::METHOD-COMBINATION-TYPE
-   PCL::UNDEFMETHOD-1 PCL::STANDARD-GENERIC-FUNCTION-P
-   PCL::STANDARD-READER-METHOD-P PCL::STANDARD-METHOD-P
-   PCL::STANDARD-ACCESSOR-METHOD-P PCL::CHECK-WRAPPER-VALIDITY
-   PCL::GMAKUNBOUND PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 PCL::METHOD-P
-   PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST PCL::STRUCTURE-WRAPPER
-   PCL::STRUCTURE-SLOTD-READER-FUNCTION
-   PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::STORE-FGEN
-   PCL::FORWARD-REFERENCED-CLASS-P 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::GENERIC-FUNCTION-P
-   PCL::GENERIC-FUNCTION-NAME-P 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::SHORT-METHOD-COMBINATION-P
-   PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION
-   PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::SLOT-CLASS-P
-   PCL::EARLY-CLASS-SLOTS PCL::ECD-METACLASS
-   PCL::CLASS-CAN-PRECEDE-LIST PCL::FUNCALLABLE-STANDARD-CLASS-P
-   PCL::MK-EARLY-CPL PCL::METHOD-COMBINATION-OPTIONS
-   PCL::STANDARD-SVUC-METHOD PCL::TYPE-CLASS PCL::SETFBOUNDP
-   PCL::METHOD-COMBINATION-P 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::CLASSP 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::STRUCTURE-CLASS-P PCL::SLOTS-FETCHER
-   PCL::CLASS-EQ-SPECIALIZER-P PCL::MAKE-INITFUNCTION
-   PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P
-   PCL::LONG-METHOD-COMBINATION-P PCL::CONVERT-TO-SYSTEM-TYPE
-   PCL::SPECIALIZER-OBJECT PCL::ECD-CANONICAL-SLOTS
-   PCL::TYPE-FROM-SPECIALIZER PCL::EXACT-CLASS-SPECIALIZER-P
-   PCL::LOOKUP-FGEN PCL::SPECIALIZERP 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::EQL-SPECIALIZER-P
-   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 (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
+      (NULL))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::ADD-METHOD-DECLARATIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
-   PCL::COPY-N-N)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (VALUES &REST T))
+   PCL::MAKE-A-METHOD PCL::REAL-MAKE-A-METHOD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
+   PCL::|__si::MAKE-DFUN-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (STRUCTURE) (T)) NIL)
-   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
+   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
+   PCL::GENERIC-FUNCTION-NREQ)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (NULL)) PCL::SHOW-EMF-CALL-TRACE PCL::RENEW-SYS-FILES
-   PCL::BOOTSTRAP-BUILT-IN-CLASSES PCL::SHOW-DFUN-CONSTRUCTORS
-   PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::MAKE-FAST-METHOD-CALL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-FETCH-WRAPPER PCL::MAKE-EMF-CALL)) 
+   (FUNCTION NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER :INSTANCE))
+   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
 (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 REMOVE-READER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
-   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
-   PCL::SET-CLASS-SLOT-VALUE-1 PCL::ACCESSOR-MISS
-   PCL::%INVALID-QUALIFIERS PCL::BOOTSTRAP-ACCESSOR-DEFINITION
-   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
-   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
-   PCL::|(FAST-METHOD NO-PRIMARY-METHOD (STANDARD-GENERIC-FUNCTION))|
-   PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
-   PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
-   PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
-   PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN)) 
+   (FUNCTION ((T) (T)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::PV-TABLE))
-   PCL::MAKE-PV-TABLE-INTERNAL)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (SIMPLE-ARRAY T (6)))
+   PCL::MAKE-FGEN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
+    ((T) &REST T)
     (OR
      (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
      (NULL)))
-   PCL::PRECOMPUTE-EFFECTIVE-METHODS)) 
+   ITERATE::FUNCTION-LAMBDA-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
+   (FUNCTION
+    ((T) (T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
+     (T))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
+   (FUNCTION
+    NIL
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (NULL)))
+   PCL::EMIT-N-N-WRITERS PCL::EMIT-N-N-READERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
+   (FUNCTION (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::STRING-APPEND)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (NOT (MEMBER NIL)))
-   PCL::PV-TABLE-LOOKUP-PV-ARGS)) 
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
 (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)) 
+   (FUNCTION ((T)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
+   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
-   PCL::COPY-CACHING)) 
+   (FUNCTION ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
+   PCL::COPY-PV-TABLE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -1015,73 +1524,90 @@
       (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)) 
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T))
+    (NULL))
+   PCL::%CHECK-CNM-ARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::MAKE-CPD)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (VALUES (T) (T))) PCL::COMPUTE-CODE)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
+   PCL::CACHE-NKEYS)) 
 (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)) 
+    ((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)
-     (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)) 
+   (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) &REST T)
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   ITERATE::FUNCTION-LAMBDA-P)) 
-(PROCLAIM
- '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (CLASS))| PCL::EXPAND-DEFCLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
-   PCL::GENERIC-FUNCTION-NREQ)) 
+   (FUNCTION ((T) (T) (T)) (T)) SETF::|PCL::PLIST-VALUE|
+   SETF::|PCL::METHOD-FUNCTION-GET| WALKER::WALK-DO* WALKER::WALK-IF
+   WALKER::WALK-LAMBDA WALKER::WALK-COMPILER-LET
+   WALKER::RELIST-INTERNAL WALKER::WALK-SETQ WALKER::WALK-LET
+   WALKER::WALK-MULTIPLE-VALUE-BIND WALKER::WALK-LET*
+   WALKER::WALK-SYMBOL-MACROLET WALKER::WALK-PROG WALKER::WALK-PROG*
+   WALKER::WALK-DO WALKER::WALK-LOCALLY WALKER::WALK-MACROLET
+   WALKER::WALK-NAMED-LAMBDA WALKER::WALK-UNEXPECTED-DECLARE
+   PCL::CONVERT-TABLE PCL::OPTIMIZE-GF-CALL-INTERNAL
+   PCL::TRACE-EMF-CALL-INTERNAL PCL::SET-SLOT-VALUE
+   PCL::GET-FUNCTION-GENERATOR PCL::OBSOLETE-INSTANCE-TRAP
+   PCL::FLUSH-CACHE-TRAP PCL::SET-FUNCTION-NAME-1
+   PCL::DECLARE-STRUCTURE PCL::INVALIDATE-WRAPPER
+   PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
+   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
+   PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
+   PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
+   PCL::SET-SLOT-VALUE-NORMAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (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)) 
+    ((T) (T) (T) (T))
+    (OR (MEMBER "is not a non-null atom") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) &REST T)
+    ((T) (T) (T) (T))
     (VALUES
-     (T)
      (OR
       (OR
        (OR
@@ -1105,427 +1631,393 @@
         (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)) 
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T) (T) (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-FINAL-CACHING-DFUN)) 
+   PCL::MAKE-FINAL-CHECKING-DFUN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    NIL
+    ((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-N-N-WRITERS PCL::EMIT-N-N-READERS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY CHARACTER (*)))
-   PCL::CAPITALIZE-WORDS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
-   PCL::INTERNED-SYMBOL-P)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
-   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL))
-   PCL::|__si::MAKE-INITIAL|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) NIL) PCL::NO-SLOT PCL::CPL-INCONSISTENT-ERROR
-   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
-(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) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER :INSTANCE))
-   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION (&REST T) (STRUCTURE PCL::CONSTANT-VALUE))
    PCL::|__si::MAKE-CONSTANT-VALUE|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
+   (FUNCTION ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
+   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES (T) (T)))
-   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
+   (FUNCTION ((T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL:SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
-   PCL::CHANGE-CLASS-INTERNAL)) 
+   (FUNCTION ((T) (T) (T) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::FILL-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::CHECK-INITARGS-2-PLIST PCL::CHECK-INITARGS-2-LIST
-   PCL::CHECK-INITARGS-1)) 
+   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::COPY-ONE-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
-   PCL::SYMBOL-OR-CONS-LESSP)) 
+   (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
-    ((T) (T) (T) &REST T)
+    ((T) (T))
     (OR
      (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
      (NULL)))
-   WALKER::WALK-ARGLIST PCL::CAN-OPTIMIZE-ACCESS1)) 
+   WALKER::WALK-REPEAT-EVAL PCL::COMPUTE-STD-CPL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES
-     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (SYSTEM:TRUE)))
-   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
+   PCL::|__si::MAKE-PV-TABLE|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    (&REST T)
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::MAKE-PROGN)) 
+    ((T)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
+   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::METHOD-CALL)) (T))
-   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
+   (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))
-    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CHECKING-OR-CACHING)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
-   PCL::ONE-CLASS-DFUN-INFO)) 
+    ((T) (T) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
+   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
 (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)) 
+    ((T) (T))
+    (OR
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))
+     (MEMBER NIL)))
+   PCL::METHODS-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
-   PCL::CACHE-NKEYS)) 
+   (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 ((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))|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::|__si::MAKE-ARG-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
-   PCL::SET-ARG-INFO1)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHE)) (T)) PCL::CACHE-OWNER)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
+   PCL::ACCESSOR-VALUES)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-    (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION)) 
+    ((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
-    ((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)) 
+    ((INTEGER 0 9223372036854775807) (T) &REST T)
+    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::FIND-FREE-CACHE-LINE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (OR
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::CHECKING))
-      (MEMBER NIL))))
-   PCL::MAKE-FINAL-CHECKING-DFUN)) 
+   (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) (T) (T))
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
-   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
-   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
-(PROCLAIM
- '(FTYPE
-   (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)) 
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
-   PCL::CHECKING-DFUN-INFO)) 
+ '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
-   PCL::CACHE-MISS-VALUES-INTERNAL)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::CONSTANT-VALUE-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) &REST T)
+    ((T) (T))
     (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   ITERATE::RENAME-LET-BINDINGS)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::INITIAL)) (T)) PCL::INITIAL-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::RESET-INITIALIZE-INFO)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::SAUT-NOT)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (VALUES (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (NULL)))
-   PCL::EMIT-READER/WRITER-FUNCTION
-   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION)) 
+     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   ITERATE::PARSE-DECLARATIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (OR (SYSTEM:TRUE) (NULL))) SLOT-EXISTS-P
-   PCL::SUPERCLASSES-COMPATIBLE-P PCL::DO-SATISFIES-DEFTYPE
-   PCL::QUALIFIER-CHECK-RUNTIME PCL::SAUT-NOT-CLASS-EQ
-   PCL::SAUT-NOT-EQL PCL::SAUT-NOT-PROTOTYPE PCL::SAUT-NOT-CLASS
-   PCL::LIST-EQ)) 
+   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::MAKE-CPD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
+    ((T) (T))
+    (OR
+     (OR
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION))
-     &REST T)
-    (VALUES &REST T))
-   PCL::MAP-ALL-CLASSES)) 
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::FIND-SUPERCLASS-CHAIN
+   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T)
+    ((T) (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) (T) (T)) (T))
-   PCL::LOAD-DEFMETHOD-INTERNAL)) 
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (SYSTEM:TRUE)))
+   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (VALUES &REST T))
-   PCL:COMPUTE-APPLICABLE-METHODS-USING-CLASSES PCL:MAP-DEPENDENTS
-   PCL:REMOVE-DIRECT-SUBCLASS PRINT-OBJECT
-   PCL:COMPUTE-EFFECTIVE-SLOT-DEFINITION PCL:REMOVE-DIRECT-METHOD
-   PCL:VALIDATE-SUPERCLASS PCL:ADD-DIRECT-SUBCLASS ADD-METHOD
-   PCL:ADD-DIRECT-METHOD PCL:ADD-DEPENDENT PCL:REMOVE-DEPENDENT
-   SLOT-VALUE PCL:EFFECTIVE-SLOT-DEFINITION-CLASS
-   PCL:DIRECT-SLOT-DEFINITION-CLASS REMOVE-METHOD
-   COMPUTE-APPLICABLE-METHODS DESCRIBE-OBJECT
-   PCL::LEGAL-DOCUMENTATION-P PCL::REMOVE-BOUNDP-METHOD
-   PCL::%NO-PRIMARY-METHOD PCL::LEGAL-SPECIALIZER-P
-   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
-   PCL::MAKE-DIRECT-SLOTD PCL::LEGAL-QUALIFIER-P PCL::CLASS-SLOT-VALUE
-   PCL::DEFAULT-INITARGS PCL::UPDATE-SLOT-VALUE-GF-INFO
-   PCL::LEGAL-SLOT-NAME-P PCL::COMPUTE-TEST PCL::SLOTS-TO-INSPECT
-   PCL::SAME-SPECIALIZER-P PCL::SDFUN-FOR-CACHING
-   PCL::LEGAL-METHOD-FUNCTION-P PCL::MAKE-READER-METHOD-FUNCTION
-   PCL::SLOT-ACCESSOR-FUNCTION PCL::SLOT-ACCESSOR-STD-P
-   PCL::LEGAL-SPECIALIZERS-P PCL::MAKE-WRITER-METHOD-FUNCTION
-   PCL::LEGAL-QUALIFIERS-P PCL::INVOKE-EMF
-   PCL::MAKE-BOUNDP-METHOD-FUNCTION PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS
-   DOCUMENTATION PCL::SLOT-VALUE-NORMAL
-   PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::REMOVE-WRITER-METHOD
-   PCL::UPDATE-GF-DFUN PCL::INITIAL-DFUN PCL::REMOVE-READER-METHOD)) 
+   (FUNCTION
+    ((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))
-    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-CONSTANT-VALUE)) 
+    ((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)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL PCL::ENSURE-CLASS-VALUES)) 
+   (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
-    ((T))
-    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
+   (FUNCTION ((STRUCTURE PCL::METHOD-CALL)) (T))
+   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
-   PCL::COPY-STD-INSTANCE)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::CACHE-VALUEP)) 
 (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::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
-    ((INTEGER 0 9223372036854775807) (T) &REST T)
-    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::FIND-FREE-CACHE-LINE)) 
-(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)) (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)) 
+    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::CHECK-INITARGS-VALUES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
-   PCL::EXPAND-CACHE)) 
+   (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) (T) (T) (T))
-    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
-   PCL::MAKE-INSTANCE-FUNCTION-COMPLEX)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
-   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
+    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
+   PCL::SYMBOL-OR-CONS-LESSP)) 
 (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 ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T))
-    (VALUES
-     (INTEGER 0 268435455) (T)
-     (OR
-      (OR
-       (OR
-        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-        (SIMPLE-ARRAY BIT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-        (SIMPLE-ARRAY SHORT-FLOAT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-        (SIMPLE-ARRAY FIXNUM (*)))
-       (OR
-        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-        (SYSTEM::NON-SIMPLE-ARRAY T *)
-        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-     (INTEGER 0 268435455) (STRUCTURE PCL::ARG-INFO)))
-   PCL::GET-GENERIC-FUNCTION-INFO)) 
+   (FUNCTION ((T) (T)) (VALUES (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
-     (T))
-    (VALUES &REST T))
-   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|)) 
+   (FUNCTION ((STRUCTURE PCL::INITIALIZE-INFO)) (T))
+   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-WRAPPER
+   PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION
+   PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION
+   PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION
+   PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION
+   PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION
+   PCL::INITIALIZE-INFO-CACHED-NEW-KEYS
+   PCL::INITIALIZE-INFO-CACHED-CONSTANTS PCL::INITIALIZE-INFO-KEY
+   PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::INITIALIZE-INFO-CACHED-RI-VALID-P
+   PCL::INITIALIZE-INFO-CACHED-VALID-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T)) (OR (SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY T *)))
-   PCL::ALLOCATE-CACHE-VECTOR)) 
+   (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)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -1536,70 +2028,44 @@
  '(FTYPE
    (FUNCTION
     ((T) (T) (T))
-    (OR
+    (VALUES
      (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::GENERATING-LISP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
 (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 ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
-   PCL::COPY-TWO-CLASS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
-   PCL::FILL-CACHE)) 
-(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 ((STRUCTURE PCL::ACCESSOR-DFUN-INFO)) (T))
-   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE)) 
+    ((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::INITIALIZE-INFO))
-   PCL::MAKE-INITIALIZE-INFO)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
+   PCL::|__si::MAKE-ONE-INDEX|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
-   PCL::|__si::MAKE-STD-INSTANCE|)) 
+   (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 ((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
+    ((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
@@ -1608,60 +2074,36 @@
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
    PCL::SPLIT-DECLARATIONS)) 
-(PROCLAIM '(FTYPE (FUNCTION ((T) (T) &REST T) NIL) PCL::CPL-ERROR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD 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) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
+   PCL::CACHE-MISS-VALUES-INTERNAL)) 
 (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::CHECKING)) (T)) PCL::CHECKING-CACHE
-   PCL::CHECKING-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (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)) (INTEGER 0 268435455)) PCL::EARLY-CLASS-SIZE
-   PCL::ARG-INFO-NKEYS PCL::ARG-INFO-NUMBER-REQUIRED)) 
+    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::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)) (NULL))
+   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+   PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T)
-     (OR
-      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
-     (T) (T))
-    (VALUES
-     (INTEGER -9223372036854775808 9223372036854775807) (T) (T)))
-   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL)) 
+   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
+    ((T) (T) (T) (T))
     (OR
      (OR
       (OR
@@ -1684,32 +2126,40 @@
        (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)) 
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
+   (FUNCTION ((T) (T) &REST T) (VALUES (T) (T)))
+   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (VALUES &REST T))
-   WALKER::WALK-TEMPLATE-HANDLE-REPEAT PCL::WALK-METHOD-LAMBDA
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
-   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
-   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
-   PCL::MAKE-METHOD-INITARGS-FORM
-   PCL::|(FAST-METHOD NO-NEXT-METHOD (STANDARD-GENERIC-FUNCTION STANDARD-METHOD))|
-   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|)) 
+   (FUNCTION ((T) (T) (T) (T) (T) &REST T) (T))
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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 (&REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::MAKE-INITIALIZE-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
@@ -1717,19 +2167,21 @@
       (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)) 
+      (SYSTEM:INTERPRETED-FUNCTION))
+     &REST T)
+    (VALUES &REST T))
+   PCL::MAP-ALL-CLASSES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::METHOD-CALL))
-   PCL::MAKE-METHOD-CALL)) 
+   (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
-    ((T) &REST T)
-    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
-   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
+   (FUNCTION ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
+   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
@@ -1743,257 +2195,312 @@
    PCL::MAKE-CLASS-EQ-PREDICATE PCL::MAKE-CONSTANT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE))
-   PCL::|STRUCTURE-OBJECT class constructor|)) 
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
+   PCL::COPY-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
+   (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))
-    (OR
-     (SIMPLE-ARRAY CHARACTER (*))
-     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
-   PCL::SYMBOL-PKG-NAME)) 
+    ((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) (T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHING)) (T)) PCL::CACHING-CACHE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
-   PCL::CACHE-VECTOR)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
+    ((T) (T) (T))
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
+   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
+    ((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)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
-   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
+   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
-   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::COPY-TWO-CLASS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) &REST T) (VALUES (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
-   PCL::GET-METHOD-FUNCTION)) 
+   (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 (&REST T) (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|)) 
+   (FUNCTION ((T) (T)) (OR (SYSTEM:TRUE) (NULL))) SLOT-EXISTS-P
+   PCL::SUPERCLASSES-COMPATIBLE-P PCL::DO-SATISFIES-DEFTYPE
+   PCL::QUALIFIER-CHECK-RUNTIME PCL::SAUT-NOT-CLASS-EQ
+   PCL::SAUT-NOT-EQL PCL::SAUT-NOT-PROTOTYPE PCL::SAUT-NOT-CLASS
+   PCL::LIST-EQ)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
-   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
+   (FUNCTION
+    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::INITIALIZE-INFO)) 
+   (FUNCTION
+    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::COPY-CONSTANT-VALUE)) 
 (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)) 
+   (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 (&REST T) (STRUCTURE PCL::ONE-CLASS))
-   PCL::|__si::MAKE-ONE-CLASS|)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
+   PCL::CACHE-LINE-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T))
-    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CACHING PCL::EMIT-CHECKING)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
+   PCL::CHECK-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
-   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
+   PCL::CHECKING-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
+    ((T) (T) &REST T)
     (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
+     &OPTIONAL (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)) 
+       (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 ((SYSTEM:STD-INSTANCE) (T)) (T))
-   PCL:STANDARD-INSTANCE-ACCESS)) 
+   (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) (T)) PCL::PV-WRAPPERS-FROM-PV-ARGS
-   PCL::UNTRACE-METHOD PCL::INTERN-PV-TABLE PCL::LOAD-TRUENAME)) 
+   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
+   PCL::|__si::MAKE-STD-INSTANCE|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::METHOD-CALL))
-    (OR
+    ((T) (T) (T) (T))
+    (VALUES
+     (T)
      (OR
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-     (SYSTEM:INTERPRETED-FUNCTION)))
-   PCL::METHOD-CALL-FUNCTION)) 
+      (SYSTEM::NON-SIMPLE-ARRAY T *) (SIMPLE-ARRAY T *) (MEMBER NIL))))
+   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) (T))
-    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
-   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
+    ((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 (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
+   (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
-    ((T) (T) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
-   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
-   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
+   (FUNCTION ((T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-FETCH-WRAPPER PCL::MAKE-EMF-CALL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
-    (INTEGER 0 9223372036854775807))
-   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
+    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
+    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::COMPUTE-STD-CPL-PHASE-3)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
-   PCL::COPY-CACHE-INTERNAL)) 
+   (FUNCTION ((T) (T) (T) (T)) (T)) WALKER::WALK-PROG/PROG*
+   WALKER::WALK-DO/DO* WALKER::WALK-LET/LET* PCL::BOOTSTRAP-SET-SLOT
+   PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
+   PCL::GET-WRAPPERS-FROM-CLASSES PCL::FROB-COMBINED-METHOD-ARGS
+   PCL::LOAD-LONG-DEFCOMBIN PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::MEMF-TEST-CONVERTER
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE PCL::OPTIMIZE-WRITER
+   PCL::OPTIMIZE-READER PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
+   PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|
+   PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
+   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
+   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+   PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
+   PCL::LOAD-SHORT-DEFCOMBIN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::FAST-METHOD-CALL))
-    (STRUCTURE PCL::FAST-METHOD-CALL))
-   PCL::COPY-FAST-METHOD-CALL)) 
+    ((T) (T) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T))
-    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
-   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
+   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::CAPITALIZE-WORDS)) 
 (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 (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
 (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)) 
+    ((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) (T) (T)) (SIMPLE-ARRAY T (6)))
-   PCL::MAKE-FGEN)) 
+   (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: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)) 
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPILE-LAMBDA)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (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))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-CONSTANT-VALUE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::CACHES-TO-ALLOCATE)) 
+   (FUNCTION ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
+   PCL::COPY-N-N)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
-   PCL::|__si::MAKE-CHECKING|)) 
+   (FUNCTION ((T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::USE-DISPATCH-DFUN-P PCL::USE-CONSTANT-VALUE-DFUN-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
-    (INTEGER 0 9223372036854775807))
-   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
+    ((STRUCTURE PCL::INITIALIZE-INFO))
+    (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::COPY-INITIALIZE-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::INITIAL)) (STRUCTURE PCL::INITIAL))
-   PCL::COPY-INITIAL)) 
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
-   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (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)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::GET-ACCESSOR-METHOD-FUNCTION)) 
+   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
+   PCL::BOOTSTRAP-SLOT-INDEX)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
+   PCL::INTERNED-SYMBOL-P)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION ((T) (T) (T)) (VALUES &REST T))
@@ -2022,588 +2529,447 @@
    PCL::ADD-READER-METHOD PCL::PRINT-STD-INSTANCE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES &REST T))
-   WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1
-   PCL::MAKE-SHORT-METHOD-COMBINATION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-CLASS))
+   PCL::|__si::MAKE-ONE-CLASS|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (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
-    ((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:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
+       (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::%CHECK-CNM-ARGS)) 
-(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 ((T) (T) (T) (T) (T) (T) &REST T) (VALUES &REST T))
-   PCL::MAKE-A-METHOD PCL::REAL-MAKE-A-METHOD)) 
-(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::PRINT-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
+    ((STRUCTURE PCL::CACHE))
     (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   WALKER::WALK-BINDINGS-2)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:TRUE))
-   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
-   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|)) 
+     (OR
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::CACHE-LIMIT-FN)) 
 (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::DEFAULT-METHOD-ONLY))
+    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::COPY-DEFAULT-METHOD-ONLY)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (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))|)) 
+      (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::ACCESSOR-DFUN-INFO))
-    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
-   PCL::COPY-ACCESSOR-DFUN-INFO)) 
+    ((STRUCTURE PCL::PV-TABLE))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::PV-TABLE-PV-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (OR (MEMBER "is not a non-null atom") (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|)) 
+   (FUNCTION ((T)) (OR (SYSTEM:TRUE) (NULL))) PCL::EARLY-GF-P
+   PCL::METHOD-CALL-P PCL::ONE-INDEX-P PCL::STD-INSTANCE-P PCL::N-N-P
+   PCL::LEGAL-CLASS-NAME-P PCL::TWO-CLASS-P PCL::INITIALIZE-INFO-P
+   PCL::ONE-CLASS-P PCL::DISPATCH-P PCL::DEFAULT-STRUCTUREP
+   PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::DEFAULT-CONSTANTP
+   PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::STRUCTURE-TYPE-P
+   PCL::NO-METHODS-P PCL::CONSTANT-VALUE-P
+   PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P PCL::CACHING-P PCL::GBOUNDP
+   PCL::INITIAL-P PCL::DNET-METHODS-P PCL::FAST-METHOD-CALL-P
+   PCL::CCLOSUREP PCL::EARLY-METHOD-STANDARD-ACCESSOR-P
+   PCL::FUNCALLABLE-INSTANCE-P PCL::FIELD-TYPE-SIMPLE-TYPEP-FN
+   PCL::ONE-INDEX-DFUN-INFO-P PCL::UPDATE-C-A-M-GF-INFO PCL::CHECKING-P
+   PCL::COMPLICATED-INSTANCE-CREATION-METHOD PCL::INITIAL-DISPATCH-P
+   PCL::ARG-INFO-P PCL::DEFAULT-METHOD-ONLY-P PCL::STRUCTURE-OBJECT-P
+   PCL::PV-TABLEP PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS PCL::CACHE-P
+   PCL::%FBOUNDP PCL::STRUCTURE-INSTANCE-P
+   PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::ACCESSOR-DFUN-INFO-P
+   PCL::ARG-INFO-VALID-P PCL::FAST-INSTANCE-BOUNDP-P PCL::DFUN-INFO-P)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (T)) PCL::%%ALLOCATE-INSTANCE--CLASS
-   PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
-   PCL::GET-EFFECTIVE-METHOD-GENSYM PCL::IN-THE-COMPILER-P
-   PCL::BOOTSTRAP-META-BRAID PCL::LIST-ALL-DFUNS)) 
+   (FUNCTION
+    ((T) &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) (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 ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::EXPAND-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
-   PCL::CHECK-CACHE)) 
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
+   PCL::COPY-STD-INSTANCE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
-   PCL::COPY-NO-METHODS)) 
+    ((T) (T) (T) (INTEGER 0 9223372036854775807))
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
-   PCL::POWER-OF-TWO-CEILING)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (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)) 
+    ((T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::LIST-DFUN)) 
 (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)) 
+   (FUNCTION ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
+   PCL::N-N-ACCESSOR-TYPE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::DISPATCH))
-   PCL::|__si::MAKE-DISPATCH|)) 
+   (FUNCTION ((STRUCTURE PCL::INITIAL-DISPATCH)) (T))
+   PCL::INITIAL-DISPATCH-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
-   PCL::STRING-APPEND)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
 (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)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CHECKING)) (STRUCTURE PCL::CHECKING))
-   PCL::COPY-CHECKING)) 
+   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-INDEX))
-   PCL::ONE-INDEX-DFUN-INFO)) 
+   (FUNCTION ((T) (T) (T) (INTEGER 0 268435455) (T)) (T))
+   PCL::UPDATE-SLOTS-IN-PV)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
+   (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)) (VALUES &OPTIONAL (T) (T)))
-   PCL::ACCESSOR-VALUES)) 
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (MEMBER "a string or NULL") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (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 ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
+   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
-   PCL::CONSTANT-VALUE-DFUN-INFO)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (MEMBER #())) PCL::COMPUTE-CALLS)) 
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (T)))
+   PCL::GET-FUNCTION1)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T) (T) (T) (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)) 
+   WALKER::WALK-BINDINGS-2)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EXPAND-EMF-CALL-METHOD
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
-   PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1 PCL::OPTIMIZE-ACCESSOR-CALL
-   PCL::REAL-MAKE-METHOD-INITARGS-FORM)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
-   PCL::CHECK-INITARGS-VALUES)) 
+    ((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) &REST T) (VALUES (T) (T) (T)))
-   PCL::PARSE-METHOD-OR-SPEC)) 
+   (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) (T))
-    (VALUES
-     (OR
-      (OR
-       (OR
-        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-        (SIMPLE-ARRAY BIT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-        (SIMPLE-ARRAY SHORT-FLOAT (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-        (SIMPLE-ARRAY FIXNUM (*)))
-       (OR
-        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-        (SYSTEM::NON-SIMPLE-ARRAY T *)
-        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
+    ((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 ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
-   PCL::N-N-ACCESSOR-TYPE)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
-   PCL::%STD-INSTANCE-WRAPPER)) 
+   (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)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::ONE-CLASS-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T))
+    ((T))
     (VALUES
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|)) 
+     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
+     (T)))
+   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
-    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::COMPUTE-STD-CPL-PHASE-3)) 
+    ((T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CACHING PCL::EMIT-CHECKING)) 
 (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)) 
+   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
-   PCL::|__si::MAKE-ONE-INDEX|)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
 (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)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
+   PCL::|__si::MAKE-CHECKING|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
-   PCL::COPY-METHOD-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
-   PCL::SYMBOL-LESSP)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-   PCL::MAKE-FAST-INSTANCE-BOUNDP)) 
+    ((T) (INTEGER 0 9223372036854775807) &REST T)
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE-FROM-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
+   (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
-      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
-      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
-      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+    ((T) (T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
      (NULL)))
-   PCL::GENERATING-LISP)) 
+   PCL::PRECOMPUTE-EFFECTIVE-METHODS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (INTEGER 0 9223372036854775807))
-    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::FILL-CACHE-FROM-CACHE-P)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
+   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
+   PCL::CACHE-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO1)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
+    ((STRUCTURE PCL::PV-TABLE))
     (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)) 
+     (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))
-    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::FORM-LIST-TO-LISP)) 
+   (FUNCTION (&REST T) (STRUCTURE))
+   PCL::|STRUCTURE-OBJECT class constructor|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (VALUES &REST T))
-   PCL:ENSURE-CLASS-USING-CLASS PCL:ENSURE-GENERIC-FUNCTION-USING-CLASS
-   PCL:WRITER-METHOD-CLASS SHARED-INITIALIZE NO-NEXT-METHOD
-   CHANGE-CLASS UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
-   PCL:READER-METHOD-CLASS PCL::SLOT-VALUE-OR-DEFAULT
-   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION
-   PCL::GET-EFFECTIVE-METHOD-FUNCTION
-   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION WALKER:NESTED-WALK-FORM
-   PCL::SYMBOL-APPEND PCL::LOAD-DEFGENERIC)) 
+   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
-   PCL::FALSE)) 
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
+    ((T))
+    (OR
+     (SIMPLE-ARRAY CHARACTER (*))
+     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
+   PCL::SYMBOL-PKG-NAME)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::INITIALIZE-INFO)) (T))
-   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
-   PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION
-   PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION
-   PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION
-   PCL::INITIALIZE-INFO-CACHED-NEW-KEYS
-   PCL::INITIALIZE-INFO-CACHED-CONSTANTS PCL::INITIALIZE-INFO-KEY
-   PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
-   PCL::INITIALIZE-INFO-CACHED-RI-VALID-P
-   PCL::INITIALIZE-INFO-CACHED-VALID-P)) 
+   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
+   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     &REST T)
-    (VALUES
-     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::PARSE-SPECIALIZED-LAMBDA-LIST)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
-   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
+   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::TWO-CLASS-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::MAKE-EARLY-ACCESSOR PCL::MAKE-UNORDERED-METHODS-EMF
-   PCL::ACCESSOR-MISS-FUNCTION)) 
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
+   PCL::%STD-INSTANCE-WRAPPER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (T)) WALKER::RELIST WALKER::RELIST*
-   FIND-CLASS PCL::ALLOCATE-STRUCTURE-INSTANCE
-   PCL::ALLOCATE-STANDARD-INSTANCE PCL::EARLY-FIND-CLASS-SYMBOL
-   PCL::INITIALIZE-METHOD-FUNCTION PCL::MAKE-FINAL-DFUN
-   PCL::MAKE-SPECIALIZABLE PCL::FIND-CLASS-CELL
-   PCL::FIND-CLASS-PREDICATE PCL::UPDATE-DFUN PCL::TRACE-METHOD
-   PCL::SET-DFUN PCL::EARLY-METHOD-SPECIALIZERS)) 
+   (FUNCTION ((T)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
+   PCL::NEXT-WRAPPER-FIELD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (T)) SETF::|COMMON-LISP::FIND-CLASS|
-   WALKER::CONVERT-MACRO-TO-LAMBDA PCL::MAKE-EMF-FROM-METHOD
-   PCL::PROBE-CACHE PCL::GET-EFFECTIVE-METHOD-FUNCTION1
-   PCL::GET-METHOD-FUNCTION-PV-CELL
-   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::METHOD-FUNCTION-GET
-   PCL::REAL-ADD-METHOD PCL::GET-DECLARATION
-   PCL::FIND-CLASS-PREDICATE-FROM-CELL PCL::FIND-CLASS-FROM-CELL
-   PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
-   PCL::REAL-ENSURE-GF-USING-CLASS--NULL)) 
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::CACHE))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   PCL::CACHE-OVERFLOW)) 
+    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::KEY-NAMES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
-   PCL::COPY-DFUN-INFO)) 
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING)) 
 (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)) 
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::ONE-INDEX-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
+   (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 (SYSTEM:TRUE) (NULL))))
-   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|)) 
+   PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T) (T) (T))
-    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
-   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|)) 
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL)) 
 (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)) 
+   (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)) 
 (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)) 
+     &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 ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
-   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
+   (FUNCTION
+    ((T)) (OR (SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY T *)))
+   PCL::ALLOCATE-CACHE-VECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (SYSTEM:TRUE))
-   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
+   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
+   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (NOT (MEMBER NIL))) PCL::EARLY-CLASS-DEFINITION
-   PCL::GET-PV-CELL-FOR-CLASS)) 
+   (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)
+    ((T) (T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
      (OR
+      (MEMBER NIL)
       (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
-    (VALUES &REST T))
-   PCL::ORDER-SPECIALIZERS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
-   PCL::MAKE-FAST-METHOD-CALL)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   PCL::EXPAND-DEFMETHOD)) 
+       (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
@@ -2617,24 +2983,32 @@
    PCL::MAP-ALL-ORDERS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
-   PCL::|__si::MAKE-DFUN-INFO|)) 
+   (FUNCTION ((T) &REST T) (NOT (MEMBER NIL)))
+   PCL::PV-TABLE-LOOKUP-PV-ARGS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
-   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
+   PCL::|__si::MAKE-NO-METHODS|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
+   (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) (T) (T) (T))
+    ((T))
     (OR
      (OR
       (OR
@@ -2657,727 +3031,492 @@
        (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))|)) 
+   PCL::SORT-CALLS PCL::METHOD-LL->GENERIC-FUNCTION-LL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
-   PCL::COPY-ONE-INDEX)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (T))
-   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+   (FUNCTION
+    ((T) (T) (T)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
     ((T) (T) (T) (T) (T) (T))
-    (OR
-     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-     (NULL)))
-   PCL::OPTIMIZE-GF-CALL)) 
+    (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
+   (FUNCTION ((T) (T) (STRUCTURE) (T)) NIL)
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (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))))))
+   PCL::DESTRUCTURE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
-   PCL:SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
+   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
 (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 ((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) &REST T)
-    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
-   MAKE-LOAD-FORM-SAVING-SLOTS)) 
+    ((T) (T))
+    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-AND)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
-   PCL::|__si::MAKE-NO-METHODS|)) 
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
-   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
-   PCL::CACHE-SIZE)) 
+   (FUNCTION ((T) (T) (T)) (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) (T))
-    (VALUES
-     (T)
-     (OR
-      (SYSTEM::NON-SIMPLE-ARRAY T *) (SIMPLE-ARRAY T *) (MEMBER NIL))))
-   PCL::MAKE-SHARED-INITIALIZE-FORM-LIST)) 
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
-   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
+   (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) (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)) 
+    ((T) (T))
+    (OR
+     (MEMBER
+      PCL:STANDARD-INSTANCE PCL::STRUCTURE-INSTANCE
+      PCL::BUILT-IN-INSTANCE PCL::SLOT-INSTANCE CLASS)
+     (MEMBER T)))
+   PCL::RAISE-METATYPE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
+    ((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) &REST T) (NULL)) ITERATE::MAYBE-WARN
-   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
+   (FUNCTION ((T) (T) (T) (T)) (VALUES))
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT 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) (T) (T) (T) (T) (T) (T)) (T))
-   PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
+    ((T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
+   (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 (&REST T) (STRUCTURE PCL::TWO-CLASS))
-   PCL::|__si::MAKE-TWO-CLASS|)) 
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
-   PCL::BOOTSTRAP-SLOT-INDEX)) 
+   (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::INITIAL-DISPATCH)) (T))
-   PCL::INITIAL-DISPATCH-CACHE)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
+   PCL::COPY-CACHE-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
-   PCL::|__si::MAKE-CACHING|)) 
+   (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) &REST T) (T)) PCL::ADD-NAMED-METHOD
-   PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE)) 
+   (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) &REST T)
-    (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
+    ((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
-    ((INTEGER 0 9223372036854775807) (T) (T))
-    (VALUES
-     (INTEGER 0 9223372036854775807) (INTEGER 0 9223372036854775807)
-     (INTEGER 1 4611686018427387904) (INTEGER 0 9223372036854775807)))
-   PCL::COMPUTE-CACHE-PARAMETERS)) 
+    ((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::INITIAL-DISPATCH))
-    (STRUCTURE PCL::INITIAL-DISPATCH))
-   PCL::COPY-INITIAL-DISPATCH)) 
+   (FUNCTION ((T) &REST T) (NULL)) ITERATE::MAYBE-WARN
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
-   PCL::COPY-ARG-INFO)) 
+   (FUNCTION NIL (NULL)) PCL::SHOW-EMF-CALL-TRACE PCL::RENEW-SYS-FILES
+   PCL::BOOTSTRAP-BUILT-IN-CLASSES PCL::SHOW-DFUN-CONSTRUCTORS
+   PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::INITIALIZE-INFO))
-    (STRUCTURE PCL::INITIALIZE-INFO))
-   PCL::COPY-INITIALIZE-INFO)) 
-(PROCLAIM '(FTYPE (FUNCTION (&REST T) (INTEGER 0 0)) PCL::ZERO)) 
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (T)) PCL::CHECKING-CACHE
+   PCL::CHECKING-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 (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
+   PCL::FALSE)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
-   PCL::GET-MAKE-INSTANCE-FUNCTION)) 
+    ((T) (T))
+    (VALUES (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::FORM-LIST-TO-LISP)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
-   ITERATE::SEQUENCE-ACCESSOR)) 
+   (FUNCTION ((STRUCTURE PCL::INITIAL)) (STRUCTURE PCL::INITIAL))
+   PCL::COPY-INITIAL)) 
 (PROCLAIM
  '(FTYPE
-   (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)) 
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
+   PCL::CACHE-VECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (VALUES))
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|)) 
-(PROCLAIM '(FTYPE (FUNCTION (&REST T) (SYSTEM:TRUE)) PCL::TRUE)) 
+   (FUNCTION
+    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
+   PCL::COPY-METHOD-CALL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
+   (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) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
-   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
+   (FUNCTION
+    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
+   PCL::POWER-OF-TWO-CEILING)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T))
-    (VALUES
-     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
-     (T)))
-   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T)) (STRUCTURE PCL::N-N)) PCL::N-N-DFUN-INFO)) 
+    ((STRUCTURE PCL::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
+   PCL::COPY-NO-METHODS)) 
 (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)) 
+    ((T) (T) (T) (T) (T) (T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MEMF-CODE-CONVERTER)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
-   PCL::NEXT-WRAPPER-FIELD)) 
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:TRUE))
+   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
-   PCL::SET-ARG-INFO)) 
+   (FUNCTION
+    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
 (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) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
 (PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     (T)
-     (OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL))))
-   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
+ '(FTYPE (FUNCTION ((T) (T)) (VALUES (T) (T))) PCL::COMPUTE-CODE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
-   WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
-   ITERATE::OPTIMIZE-ITERATE-FORM ITERATE::SIMPLE-EXPAND-GATHERING-FORM
-   ITERATE::RENAME-AND-CAPTURE-VARIABLES PCL::MAKE-METHOD-SPEC
-   PCL::EXPAND-DEFGENERIC PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
-   PCL::FIRST-FORM-TO-LISP PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
-   PCL::EMIT-BOUNDP-CHECK PCL::MAKE-TOP-LEVEL-FORM
-   PCL::EMIT-SLOT-READ-FORM PCL::EMIT-1-T-DLAP PCL::MAKE-DFUN-CALL)) 
+   (FUNCTION ((T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) (T))
-   PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
-   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
-   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-EMF-CACHE
-   PCL::UPDATE-SLOTS-IN-PV
-   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
-   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-   PCL::LOAD-FUNCTION-GENERATOR PCL::COMPUTE-PV-SLOT)) 
+   (FUNCTION ((T) (T) (T) (T) &REST T) (T)) PCL::ADD-NAMED-METHOD
+   PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
-   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
+   (FUNCTION ((T) (T)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (OR
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
-       (STRUCTURE PCL::CHECKING))
-      (MEMBER NIL))))
-   PCL::MAKE-CHECKING-DFUN)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (T))
+   PCL::LOAD-DEFMETHOD-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
-   PCL::COMPUTE-LINE-SIZE)) 
-(PROCLAIM
- '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
+   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::PARSE-QUALIFIER-PATTERN)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T) (T)) NIL)
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
-   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
-   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION ((T) &REST T) (VALUES (T) (T) (T)))
+   PCL::PARSE-METHOD-OR-SPEC)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
-   PCL::CACHE-LINE-SIZE)) 
+   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
+   PCL::COMPUTE-LINE-SIZE)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (OR (MEMBER "a function") (MEMBER T)))
-   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|)) 
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
-      (OR
-       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
-      (NULL)))
+    ((T) &REST T)
     (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)) 
-(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)) 
+     (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
-   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::PV-TABLE))
+   PCL::MAKE-PV-TABLE-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (T)) PCL::ONE-INDEX-CACHE
-   PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-ACCESSOR-TYPE)) 
+   (FUNCTION ((SYSTEM:STD-INSTANCE) (T)) (T))
+   PCL:STANDARD-INSTANCE-ACCESS)) 
 (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 (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
-   PCL::|__si::MAKE-PV-TABLE|)) 
+    ((T) (T) (T))
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::CHANGE-CLASS-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
-   PCL::CACHE-VALUEP)) 
+   (FUNCTION ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
-   PCL::COPY-DEFAULT-METHOD-ONLY)) 
+    ((T) (T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::PV-TABLE))
-    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
-   PCL::PV-TABLE-CACHE)) 
+   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::LOAD-DEFMETHOD)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((OR
+    ((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)))
-    (NULL))
-   PCL::MAP-SPECIALIZERS PCL::MAP-ALL-GENERIC-FUNCTIONS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
-   PCL::COPY-DISPATCH)) 
-(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))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
-   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
-(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::ARG-INFO))
-   PCL::|__si::MAKE-ARG-INFO|)) 
+   PCL::GENERATE-DISCRIMINATION-NET-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
-   PCL::TWO-CLASS-DFUN-INFO)) 
+   (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)) (OR (INTEGER 0 12) (MEMBER NIL)))
-   PCL::WRAPPER-FIELD)) 
+   (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) &REST T)
-    (VALUES
-     &OPTIONAL (T) (T)
-     (OR
-      (MEMBER NIL)
-      (OR
-       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
-       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
-       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)))))
-   PCL::MAKE-FINAL-ACCESSOR-DFUN)) 
+   (FUNCTION ((T) (T) (T) (NULL) (T)) (T))
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T))
-    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
-   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
+    ((T) (T) (T))
+    (VALUES &OPTIONAL (T) (T) (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
+   PCL::CACHE-MISS-VALUES)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) &REST T)
-    (VALUES
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION))
-     (T)))
-   PCL::GET-FUNCTION1)) 
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((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)) 
+     (OR
+      (MEMBER "is not a symbol and so cannot be bound")
+      (MEMBER "is a keyword and so cannot be bound")
+      (MEMBER "is a constant and so cannot be bound")
+      (MEMBER "cannot be bound"))
+     (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
-(PROCLAIM
- '(FTYPE (FUNCTION ((T) (T) (T) &REST T) (T)) PCL::REAL-GET-METHOD)) 
+    (&REST T)
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::MAKE-PROGN)) 
 (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))|)) 
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
+   PCL::|__si::MAKE-CACHING|)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (VALUES &REST T)) MAKE-INSTANCES-OBSOLETE
-   METHOD-QUALIFIERS PCL:METHOD-LAMBDA-LIST FUNCTION-KEYWORDS
-   PCL:SPECIALIZER-DIRECT-METHODS PCL:METHOD-SPECIALIZERS
-   PCL:SLOT-DEFINITION-ALLOCATION PCL:COMPUTE-CLASS-PRECEDENCE-LIST
-   PCL:CLASS-FINALIZED-P PCL:COMPUTE-DISCRIMINATING-FUNCTION
-   PCL:CLASS-DEFAULT-INITARGS PCL:CLASS-DIRECT-SLOTS
-   PCL:GENERIC-FUNCTION-LAMBDA-LIST PCL:FINALIZE-INHERITANCE
-   PCL:COMPUTE-SLOTS PCL:CLASS-SLOTS PCL:METHOD-FUNCTION
-   PCL:CLASS-PROTOTYPE PCL:CLASS-DIRECT-DEFAULT-INITARGS
-   PCL::INTERN-FUNCTION-NAME PCL::COMPILE-IIS-FUNCTIONS
-   PCL::|ARG-INFO SLOT10| PCL::MAKE-KEYWORD PCL::|PV-TABLE SLOT3|
-   PCL::|CHECKING SLOT1| PCL::|PV-TABLE SLOT2| PCL::SLOT-WRITER-SYMBOL
-   PCL::|PV-TABLE SLOT1|
-   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO
-   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::|PV-TABLE SLOT0|
-   PCL::|DFUN-INFO SLOT0|
-   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
-   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
-   PCL::|SYSTEM:S-DATA SLOT9| PCL::|SYSTEM:S-DATA SLOT8|
-   PCL::|SYSTEM:S-DATA SLOT7| PCL::|SYSTEM:S-DATA SLOT6|
-   PCL::|SYSTEM:S-DATA SLOT5| PCL::|SYSTEM:S-DATA SLOT4|
-   PCL::|SYSTEM:S-DATA SLOT3| PCL::COMPUTE-DEFAULT-INITARGS
-   PCL::|SYSTEM:S-DATA SLOT2| PCL::|SYSTEM:S-DATA SLOT1|
-   PCL::|SYSTEM:S-DATA SLOT0| PCL::DFUN-ARG-SYMBOL
-   PCL::CLASS-SLOT-CELLS PCL::SLOT-BOUNDP-SYMBOL
-   PCL::|METHOD-CALL SLOT1| PCL::|METHOD-CALL SLOT0|
-   PCL::GF-FAST-METHOD-FUNCTION-P PCL::|INITIALIZE-INFO SLOT9|
-   PCL::|INITIALIZE-INFO SLOT8| PCL::|INITIALIZE-INFO SLOT7|
-   PCL::|INITIALIZE-INFO SLOT6| PCL::|INITIALIZE-INFO SLOT5|
-   PCL::|INITIALIZE-INFO SLOT4| PCL::|INITIALIZE-INFO SLOT3|
-   PCL::|INITIALIZE-INFO SLOT2| PCL::|INITIALIZE-INFO SLOT1|
-   PCL::|INITIALIZE-INFO SLOT0| PCL::|CACHE SLOT11| PCL::|CACHE SLOT10|
-   PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::MAKE-CLASS-PREDICATE-NAME
-   PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS PCL::CLASS-CONSTRUCTORS
-   PCL::|ARG-INFO SLOT9| PCL::|ARG-INFO SLOT8| PCL::|ARG-INFO SLOT7|
-   PCL::|ARG-INFO SLOT6| PCL::|ARG-INFO SLOT5| PCL::|ARG-INFO SLOT4|
-   PCL::|COMPILER::FN SLOT8| PCL::|ARG-INFO SLOT3|
-   PCL::SPECIALIZER-METHOD-TABLE PCL::|COMPILER::FN SLOT7|
-   PCL::|ARG-INFO SLOT2| PCL::|COMPILER::FN SLOT6|
-   PCL::|ARG-INFO SLOT1| PCL::|COMPILER::FN SLOT5|
-   PCL::|ARG-INFO SLOT0| PCL::|COMPILER::FN SLOT4|
-   PCL::|COMPILER::FN SLOT3| PCL::|COMPILER::FN SLOT2|
-   PCL::|COMPILER::FN SLOT1| PCL::|COMPILER::FN SLOT0|
-   PCL::|TYPE-PREDICATE COMMON-LISP STRUCTURE-CLASS|
-   PCL::|TYPE-PREDICATE COMMON-LISP BUILT-IN-CLASS|
-   PCL::|TYPE-PREDICATE PCL FORWARD-REFERENCED-CLASS|
-   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-CLASS|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-CLASS|
-   PCL::|TYPE-PREDICATE PCL STD-CLASS|
-   PCL::|TYPE-PREDICATE PCL SLOT-CLASS|
-   PCL::|TYPE-PREDICATE PCL PCL-CLASS|
-   PCL::|TYPE-PREDICATE COMMON-LISP CLASS|
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER-WITH-OBJECT|
-   PCL::|TYPE-PREDICATE PCL FUNCALLABLE-STANDARD-OBJECT|
-   PCL::|TYPE-PREDICATE PCL METAOBJECT|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-OBJECT|
-   PCL::|TYPE-PREDICATE PCL SHORT-METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE PCL LONG-METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE COMMON-LISP METHOD-COMBINATION|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-GENERIC-FUNCTION|
-   PCL::|TYPE-PREDICATE COMMON-LISP GENERIC-FUNCTION|
-   PCL::|TYPE-PREDICATE PCL STRUCTURE-EFFECTIVE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STRUCTURE-DIRECT-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-EFFECTIVE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-DIRECT-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL EFFECTIVE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL DIRECT-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STRUCTURE-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL STANDARD-SLOT-DEFINITION|
-   PCL::|TYPE-PREDICATE PCL SLOT-DEFINITION| PCL::GET-DISPATCH-FUNCTION
-   PCL::|FAST-METHOD-CALL SLOT3| PCL::|FAST-METHOD-CALL SLOT2|
-   PCL::INITIALIZE-INTERNAL-SLOT-FUNCTIONS
-   PCL::|FAST-METHOD-CALL SLOT1| PCL::GF-LAMBDA-LIST
-   PCL::|FAST-METHOD-CALL SLOT0| PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
-   PCL::|TYPE-PREDICATE PCL TRACED-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-BOUNDP-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-WRITER-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-READER-METHOD|
-   PCL::|TYPE-PREDICATE PCL STANDARD-ACCESSOR-METHOD|
-   PCL::|TYPE-PREDICATE COMMON-LISP STANDARD-METHOD|
-   PCL::|TYPE-PREDICATE COMMON-LISP METHOD| PCL::|SYSTEM:S-DATA SLOT17|
-   PCL::|SYSTEM:S-DATA SLOT16| PCL::|SYSTEM:S-DATA SLOT15|
-   PCL::|SYSTEM:S-DATA SLOT14| PCL::|SYSTEM:S-DATA SLOT13|
-   PCL::|SYSTEM:S-DATA SLOT12| PCL::|SYSTEM:S-DATA SLOT11|
-   PCL::|SYSTEM:S-DATA SLOT10| PCL::|ONE-INDEX-DFUN-INFO SLOT2|
-   PCL::CLASS-PREDICATE-NAME PCL::|TWO-CLASS SLOT4| PCL::|CACHE SLOT9|
-   PCL::GENERIC-FUNCTION-PRETTY-ARGLIST PCL::|CACHE SLOT8|
-   PCL::|CACHE SLOT7| PCL::|CACHE SLOT6| PCL::|CACHE SLOT5|
-   PCL::|CACHE SLOT4| PCL::|CACHE SLOT3| PCL::ACCESSOR-METHOD-CLASS
-   PCL::|CACHE SLOT2| PCL::|CACHE SLOT1| PCL::|CACHE SLOT0|
-   PCL::|ONE-CLASS SLOT3| PCL::METHOD-PRETTY-ARGLIST
-   PCL::|INITIALIZE-INFO SLOT13| PCL::KEYWORD-SPEC-NAME
-   PCL::|INITIALIZE-INFO SLOT12|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT3|
-   PCL::|INITIALIZE-INFO SLOT11|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT2|
-   PCL::|INITIALIZE-INFO SLOT10|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT1|
-   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT0| PCL::|MODULE SLOT4|
-   PCL::|MODULE SLOT3| PCL::|MODULE SLOT2| PCL::SPECIALIZER-CLASS
-   PCL::|MODULE SLOT1| PCL::ACCESSOR-METHOD-SLOT-NAME
-   PCL::|MODULE SLOT0| PCL::METHOD-PROTOTYPE-FOR-GF
-   PCL::SLOT-VECTOR-SYMBOL PCL::SLOT-READER-SYMBOL
-   PCL::SPECIALIZER-FROM-TYPE PCL::INSURE-CACHING-DFUN
-   PCL::|ACCESSOR-DFUN-INFO SLOT1| PCL::|FAST-INSTANCE-BOUNDP SLOT0|)) 
+   (FUNCTION ((T) (T) (T) (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)
-     (OR
-      (OR
-       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
-       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
-      (SYSTEM:INTERPRETED-FUNCTION)))
+    ((T) (T) (T))
     (OR
-     (OR
-      (OR
-       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
-       (SIMPLE-ARRAY BIT (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
-       (SIMPLE-ARRAY SHORT-FLOAT (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
-       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
-       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
-       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
-       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
-       (SIMPLE-ARRAY FIXNUM (*)))
-      (OR
-       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
-       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::SORT-METHODS)) 
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-TAGBODY WALKER::WALK-TAGBODY-1 WALKER::WALK-LABELS
+   WALKER::WALK-FLET WALKER::RECONS WALKER:VARIABLE-DECLARATION
+   PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| 
+   PCL::CAN-OPTIMIZE-ACCESS)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T))
-    (VALUES
-     (SYSTEM:PROPER-CONS (T) (T))
-     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
-   PCL::REAL-MAKE-METHOD-LAMBDA)) 
+   (FUNCTION ((T)) (OR (INTEGER 0 12) (MEMBER NIL)))
+   PCL::WRAPPER-FIELD)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION
-    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
-   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
-(PROCLAIM '(FTYPE (FUNCTION NIL (VALUES)) PCL::COUNT-ALL-DFUNS)) 
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (STRUCTURE PCL::CHECKING))
+   PCL::COPY-CHECKING)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
+   (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 ((STRUCTURE PCL::FAST-METHOD-CALL)) (T))
-   PCL::FAST-METHOD-CALL-ARG-INFO
-   PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
-   PCL::FAST-METHOD-CALL-PV-CELL)) 
+   (FUNCTION NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
 (PROCLAIM
  '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
-   PCL::CONSTANT-VALUE-CACHE)) 
+   (FUNCTION ((T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::RESET-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))|)) 
+   (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)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
-   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+   (FUNCTION ((T) (T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T) (T) (T))
-    (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
-   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION)) 
+    ((T) (T) (T))
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
 (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)) 
+   (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) &REST T) (T))
-   PCL::LOAD-DEFMETHOD)) 
+   (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)) 
 (PROCLAIM
  '(FTYPE
    (FUNCTION
-    ((T) (T) (T) (T))
+    ((T) &REST T)
     (VALUES
+     (T)
      (OR
       (OR
        (OR
@@ -3401,127 +3540,5 @@
         (SYSTEM::NON-SIMPLE-ARRAY T *)
         (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
       (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
-     (OR (SYSTEM:TRUE) (NULL))))
-   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) &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::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
-     (MEMBER T)))
-   PCL::OPTIMIZE-SLOT-BOUNDP PCL::OPTIMIZE-SLOT-VALUE
-   PCL::OPTIMIZE-SET-SLOT-VALUE)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (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))
-    (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))
-    (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)) (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
-    ((STRUCTURE PCL::PV-TABLE))
-    (INTEGER -9223372036854775808 9223372036854775807))
-   PCL::PV-TABLE-PV-SIZE)) 
-(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)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((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)))))
-   ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::FIND-SUPERCLASS-CHAIN
-   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (STRUCTURE PCL::ONE-CLASS))
-   PCL::COPY-ONE-CLASS)) 
-(PROCLAIM
- '(FTYPE
-   (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 (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
-   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
-(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))|)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION ((T) (T) &REST T) (VALUES (T) (T)))
-   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
-   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) &REST T)
-    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::N-N)))
-   PCL::MAKE-N-N-ACCESSOR-DFUN)) 
-(PROCLAIM
- '(FTYPE
-   (FUNCTION
-    ((T) (T) (T) (T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
-   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
\ No newline at end of file
+   PCL::EXTRACT-DECLARATIONS)) 
\ No newline at end of file
