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-22) unstable; urgency=medium
 .
   * Version_2_7_0pre25
Author: Camm Maguire <camm@debian.org>

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

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

--- gcl27-2.7.0.orig/cmpnew/gcl_cmpenv.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpenv.lsp
@@ -194,8 +194,11 @@
                *function-declarations*))
         (t (warn "The function name ~s is not a symbol." fname))))
 
+(defvar *assert-ftype-proclamations* nil)
+
 (defun get-arg-types (fname &aux x)
-  (cond ((setq x (assoc fname *function-declarations*)) (mapcar 'cmp-norm-tp (cadr x)))
+  (cond ((when *assert-ftype-proclamations* (setq x (when (symbolp fname) (get fname 'proclaimed-signature)))) (car x))
+	((setq x (assoc fname *function-declarations*)) (mapcar 'cmp-norm-tp (cadr x)))
 	((setq x (local-fun-p fname)) (caar (fun-call x)))
 	((setq x (gethash fname *sigs*)) (caar x))
 	((setq x (si::sig fname)) (car x))
@@ -203,7 +206,8 @@
 	('(*))))
 
 (defun get-return-type (fname &aux x)
-  (cond ((setq x (assoc fname *function-declarations*)) (cmp-norm-tp (caddr x)))
+  (cond ((when *assert-ftype-proclamations* (setq x (when (symbolp fname) (get fname 'proclaimed-signature)))) (cadr x))
+	((setq x (assoc fname *function-declarations*)) (cmp-norm-tp (caddr x)))
 	((setq x (local-fun-p fname)) (cadar (fun-call x)))
 	((setq x (gethash fname *sigs*)) (cadar x))
 	((setq x (si::sig fname)) (cadr x))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpeval.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpeval.lsp
@@ -2762,7 +2762,7 @@
 	   (fun (when (fun-p fun) fun))
 	   (sym (car (atomic-tp (info-type (cadar nargs))))))
       (when (and sym fun);FIXME
-	(push (cons sym (apply 'si::make-function-plist (fun-call fun))) si::*sig-discovery-props*))))
+	(push (cons sym (apply 'si::make-function-plist (exp-sig (car (fun-call fun))) (cdr (fun-call fun)))) si::*sig-discovery-props*))))
   form)
 
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpif.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpif.lsp
@@ -708,7 +708,10 @@
 		(fmlae (if (notevery 'cddr inf) t   fmlae)))
 	   (when inf 
 	     (keyed-cmpnote (list* 'type-inference (mapcar (lambda (x) (var-name (car x))) inf))
-			  "inferring types on form ~s, ~s" f (mapcar (lambda (x) (list (pop x) (cmp-unnorm-tp (pop x)) (cmp-unnorm-tp x))) inf)))
+			    "inferring types on form ~s, ~s"
+			    f (mapcar (lambda (x)
+					(list (pop x) (cmp-unnorm-tp (pop x)) (cmp-unnorm-tp x)))
+				      inf)))
 	   (if (not (eq fmlae 'boolean))
 
  	       (cond (fmlae 
@@ -1147,7 +1150,7 @@
 	 (arg (pop args))
 	 (tp (or tp (co1or-arg-tp arg)))
 	 (atp (atomic-tp (type-and tp #t(not null)))))
-    (when (atomic-type-constant-value atp);FIXME make sure this is never a binding
+    (when (atomic-type-constant-value atp);FIXME make sure this is never a binding, FIXME ignorable-form?
       (c1expr (if args `(if ,arg ',(car atp) (or ,@args)) arg)))))
 
 ;; (defun co1or (fn args)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpmain.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpmain.lsp
@@ -446,18 +446,17 @@ Cannot compile ~a.~%" (namestring (merge
 	 ;; FIXME -- support warnings-p and failures-p.  CM 20041119
 	((multiple-value-setq (tem na) (get-named-form name))
 	 (let (warnings failures *compiler-compile-data*)
-	   (unless (and (fboundp 'si::init-cmp-anon) (or (si::init-cmp-anon) (fmakunbound 'si::init-cmp-anon)))
-	     (with-open-file
-	      (st (setq gaz (gazonk-name)) :direction :output))
-	     (multiple-value-bind 
-	      (fn w f)
-	      (let ((*compiler-compile* tem))
-		(compile-file gaz))
-	      (when fn 
-		(load fn)
-		(unless *keep-gaz* (delete-file fn)))
-	      (setq warnings w failures f))
-	     (unless *keep-gaz* (delete-file gaz)))
+	   (with-open-file
+	       (st (setq gaz (gazonk-name)) :direction :output))
+	   (multiple-value-bind
+		 (fn w f)
+	       (let ((*compiler-compile* tem))
+		 (compile-file gaz))
+	     (when fn
+	       (load fn)
+	       (unless *keep-gaz* (delete-file fn)))
+	     (setq warnings w failures f))
+	   (unless *keep-gaz* (delete-file gaz))
 	   (unless (eq na name) (setf (symbol-function name) (symbol-function na)))
 	   (when *tmp-pack*
 	     (delete-package *tmp-pack*)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpspecial.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpspecial.lsp
@@ -62,10 +62,11 @@
   (when (equal dtype #tboolean)
     (unless (type>= dtype (info-type info))
       (return-from c1the (c1expr `(when ,(cadr args) t)))))
-  (setq type (type-and dtype (info-type info)))
+;  (setq type (type-and dtype (info-type info)))
 
   (setq form (list* (car form) info (cddr form)))
-  (if (type>= #tboolean dtype) (setf (info-type (cadr form)) type) (set-form-type form type))
+  (set-form-type form dtype (type>= #tboolean dtype));FIXME understand boolean exception
+;  (if (type>= #tboolean dtype) (setf (info-type (cadr form)) type) (set-form-type form dtype));FIXME
 ;  (setf (info-type info) type)
   form)
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptop.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptop.lsp
@@ -1133,7 +1133,7 @@
 	  (fifth e) (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*))))
+      (when (symbol-package name) (unless (eq name 'lambda) (push (cons name (apply 'si::make-function-plist (exp-sig (pop e)) e)) si::*sig-discovery-props*))))
     l))
 
 ;; (defun do-fun (name src e vis b)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptype.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptype.lsp
@@ -776,7 +776,7 @@
 (si::putprop 'cons 'cons-propagator 'type-propagator)
 
 (defun co1carcdr (f x)
-  (let* ((tp (car (atomic-tp (info-type (cadr (with-restore-vars (c1arg (car x))))))))
+  (let* ((tp (car (atomic-tp (info-type (cadr (with-restore-vars (c1arg (car x))))))));FIXME ignorable-form
 	 (tp (when (consp tp) (funcall f tp)))
 	 (tp (get-var tp)))
     (when tp (c1var tp))))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmputil.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmputil.lsp
@@ -76,7 +76,9 @@
        (let ((,cf *current-form*)(,sri *src-inline-recursion*)) 
 	 (push (lambda nil
 		 (let ((*current-form* ,cf)
-		       (*src-inline-recursion* ,sri)) ,@body)) *warning-note-stack*))
+		       (*src-inline-recursion* ,sri))
+		   ,@body))
+	       *warning-note-stack*))
      (progn ,@body))))
 
 (defun output-warning-note-stack nil
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpvar.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpvar.lsp
@@ -631,7 +631,7 @@
 	(unless (type>= (var-mt v) tp)
 	  (setf (var-mt v) (type-and (bbump-tp (type-or1 (var-mt v) tp)) (var-dt v))))))))
 
-(defun set-form-type (form type) (sft form type))
+(defun set-form-type (form type &optional no-recur) (sft form type no-recur))
 
 ;; (defun set-form-type (form type) (setf (info-type (cadr form)) (type-and type (info-type (cadr form)))))
 ;  (sft form type))  FIXME cannot handle nil return types such as tail recursive calls
@@ -642,35 +642,40 @@
 	 (sft (car (last form)) type))
 	(t (sft-block (car form) block type) (sft-block (cdr form) block type))))
 
-(defun sft (form type)
+(defun sft (form type &optional no-recur);FIXME sft-block labels avoid mutual recursion
   (let ((it (info-type (cadr form))))
     (unless (type>= type it)
       (let ((nt (type-and type it)))
-	(when nt;FIXME
-;	  (when (eq form +c1nil+) (break))
-	  (setf (info-type (cadr form)) nt)
+	(unless nt
+	  (unless type
+	    (cmpwarn "NOT setting form type from ~s to ~s" (cmp-unnorm-tp it) (cmp-unnorm-tp type))
+	    (return-from sft nil))
+	  (cmpwarn "Setting form type ~s to orthogonal type ~s"
+		   (cmp-unnorm-tp it) (cmp-unnorm-tp type))
+	  (setq nt type))
+	(setf (info-type (cadr form)) nt)
+	(unless no-recur
 	  (case (car form)
-		(block (sft-block (fourth form) (third form) type))
-		((decl-body inline) (sft (car (last form)) type))
-		((let let*)
-		 (sft (car (last form)) type)
-		 (mapc (lambda (x y) (sft y (var-type x)))
-		       (caddr form) (cadddr form)))
-		(var (do-setq-tp (caaddr form) nil (type-and nt (var-type (caaddr form)))))
-		(progn (sft (car (last (third form))) type))
-		;; (if 
-		;;     (when (ignorable-form (third form));FIXME put third form into progn
-		;;       (let ((tt (type-and type (nil-to-t (info-type (cadr (fourth form))))))
-		;; 	    (ft (type-and type (nil-to-t (info-type (cadr (fifth form)))))))
-		;; 	(unless tt
-		;; 	  (sft (fifth form) type)
-		;; 	  (setf (car form) 'progn (cadr form) (cadr (fifth form)) (caddr form) 
-		;; 		(list (fifth form)) (cdddr form) nil))
-		;; 	(unless ft
-		;; 	  (sft (fourth form) type)
-		;; 	  (setf (car form) 'progn (cadr form) (cadr (fourth form)) (caddr form) 
-		;; 		(list (fourth form)) (cdddr form) nil)))))
-		))))))
+	    (block (sft-block (fourth form) (third form) type))
+	    ((decl-body inline) (sft (car (last form)) type))
+	    ((let let*)
+	     (sft (car (last form)) type)
+	     (mapc (lambda (x y) (sft y (var-type x)))
+		   (caddr form) (cadddr form)))
+	    (var (do-setq-tp (caaddr form) nil (type-and nt (var-type (caaddr form)))))
+	    (progn (sft (car (last (third form))) type))))))))
+	  ;; (if
+	  ;;     (when (ignorable-form (third form));FIXME put third form into progn
+	  ;;       (let ((tt (type-and type (nil-to-t (info-type (cadr (fourth form))))))
+	  ;; 	    (ft (type-and type (nil-to-t (info-type (cadr (fifth form)))))))
+	  ;; 	(unless tt
+	  ;; 	  (sft (fifth form) type)
+	  ;; 	  (setf (car form) 'progn (cadr form) (cadr (fifth form)) (caddr form)
+	  ;; 		(list (fifth form)) (cdddr form) nil))
+	  ;; 	(unless ft
+	  ;; 	  (sft (fourth form) type)
+	  ;; 	  (setf (car form) 'progn (cadr form) (cadr (fourth form)) (caddr form)
+	  ;; 		(list (fourth form)) (cdddr form) nil)))))
 
 (defun c1setq1 (name form &aux (info (make-info)) type form1 name1)
   (cmpck (not (symbolp name)) "The variable ~s is not a symbol." name)
--- gcl27-2.7.0.orig/cmpnew/gcl_collectfn.lsp
+++ gcl27-2.7.0/cmpnew/gcl_collectfn.lsp
@@ -400,3 +400,48 @@
 			       (cond ((not (eq (symbol-package v) p))
 				      (push v imp))))
 		   (pr `(import ',imp))))))))))
+
+(defun get-packages-ansi (pl &optional (st "sys-package.lisp") pass &aux (si::*print-package* t))
+  (flet ((pr (x) (format st "~%~s" x)))
+     (cond ((null pass)
+	    (with-open-file (st st :direction :output)
+	      (setq pl (sort (copy-list pl)
+			     (lambda (x y)
+			       (member (find-package y) (package-used-by-list (find-package x))))))
+	      (get-packages-ansi pl st 'establish)
+	      (get-packages-ansi pl st 'export)
+	      (get-packages-ansi pl st 'shadow)
+	      (format st "~2%")
+	      (return-from get-packages-ansi nil))))
+     (dolist (p pl)
+	   (unless
+	       (member (package-name p)
+		       '("SLOOP" "COMPILER" "SYSTEM" "KEYWORD" "LISP" "USER")
+		       :test 'equal)
+	     (format st "~2%;;; Definitions for package ~a of type ~a" (package-name p) pass)
+	     (ecase pass
+	       (establish
+		(pr `(unless (find-package ,(package-name p))
+		       (make-package ,(package-name p)
+				     :use ',(mapcar 'package-name (package-use-list p))
+				     ,@(when (package-nicknames p)
+					 `(:nicknames ',(package-nicknames p)))))))
+	       (export
+		(let (ext (*package* p) imps)
+		  (do-external-symbols (sym p)
+		    (push sym ext)
+		    (unless (eq (symbol-package sym) p)
+		      (push sym imps)))
+		  (pr `(import ',imps ,(package-name p)))
+		  (pr `(export ',ext ,(package-name p)))))
+	       (shadow (print p)
+		(let (in out (*package* (find-package "CL")))
+		  (dolist (v (package-shadowing-symbols p))
+		    (if (eq (symbol-package v) p) (push v in) (push v out)));FIXME push if
+		  (pr `(shadow ',in ,(package-name p)))
+		  (pr `(shadowing-import ',out ,(package-name p)))
+		  (let (imp)
+		    (do-symbols (v p)
+		      (unless (eq (symbol-package v) p)
+		       (push v imp)))
+		    (pr `(import ',imp ,(package-name p)))))))))))
--- gcl27-2.7.0.orig/configure
+++ gcl27-2.7.0/configure
@@ -3148,9 +3148,7 @@ case $use in
 	case $use in
 	    ia64*)
 		def_dlopen="yes" ; def_custreloc="no" ;;
-	    hppa*)
-		def_pic="yes" ;;
-	esac;;
+	    	    	esac;;
 esac
 
 # Check whether --enable-widecons was given.
@@ -8575,7 +8573,10 @@ printf "%s\n" "not found" >&6; }
 	fi
 	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking output_mach" >&5
 printf %s "checking output_mach... " >&6; }
-	output_mach=`cat gcl.script |grep OUTPUT_ARCH|head -n 1|sed 's,.*(\(.*\)).*,\1:,1'|cut -f2 -d:|tr '-' '_'`;
+	output_mach=`cat gcl.script |grep OUTPUT_ARCH|head -n 1|sed 's,.*(\(.*\)).*,\1:,1'|cut -f2 -d:|tr '-' '_'|tr -d '.'`;
+        if test "$output_mach" = "common" ; then
+	   output_mach=""
+	fi
 	defaulted=""
         if test "$output_mach" = "" ; then
 		if test "$output_arch" = "i386" ; then
--- gcl27-2.7.0.orig/configure.in
+++ gcl27-2.7.0/configure.in
@@ -83,8 +83,8 @@ case $use in
 	case $use in
 	    ia64*)
 		def_dlopen="yes" ; def_custreloc="no" ;;
-	    hppa*)
-		def_pic="yes" ;;
+	    dnl hppa*)
+	    dnl 	def_pic="yes" ;;
 	esac;;
 esac
 
@@ -1472,6 +1472,9 @@ if test "$use" != "386-gnu" ; then #hurd
 	AC_MSG_CHECKING([output_mach])
 	output_mach=`cat gcl.script |grep OUTPUT_ARCH|head -n 1|sed 's,.*(\(.*\)).*,\1:,1'|cut -f2 -d:|tr '-' '_'|tr -d '.'`;
 dnl     FIXME
+        if test "$output_mach" = "common" ; then
+	   output_mach=""
+	fi
 	defaulted=""
         if test "$output_mach" = "" ; then
 		if test "$output_arch" = "i386" ; then
--- gcl27-2.7.0.orig/git.tag
+++ gcl27-2.7.0/git.tag
@@ -1,2 +1,2 @@
-"Version_2_7_0pre24"
+"Version_2_7_0pre25"
 
--- gcl27-2.7.0.orig/h/elf32_hppa_reloc.h
+++ gcl27-2.7.0/h/elf32_hppa_reloc.h
@@ -11,18 +11,35 @@
       s>>=11;
       store_valu(where,MASK(21),ASM21(s));
       break;
+    case R_PARISC_DIR21L:
+      s+=a;
+      s>>=11;
+      store_valu(where,MASK(21),ASM21(s));
+      break;
     case R_PARISC_PCREL14R:
       s+=a;
       s-=p+11;
       s&=MASK(11);
       store_valu(where,MASK(14),s<<1);
       break;
+    case R_PARISC_DIR14R:
+      s+=a;
+      s&=MASK(11);
+      store_valu(where,MASK(14),s<<1);
+      break;
+    case R_PARISC_DIR17R:
+      s+=a;
+      s&=MASK(11);
+      store_valu(where,MASK(17),s<<1);
+      break;
     case R_PARISC_LTOFF21L:
+    case R_PARISC_DPREL21L:
       s-=pltgot;
       s>>=11;
       store_valu(where,MASK(21),ASM21(s));
       break;
     case R_PARISC_LTOFF14R:
+    case R_PARISC_DPREL14R:
       s-=pltgot;
       s&=MASK(11);
       store_valu(where,MASK(14),s<<1);
--- gcl27-2.7.0.orig/h/object.h
+++ gcl27-2.7.0/h/object.h
@@ -421,7 +421,8 @@ EXTER long holepage;			/*  hole pages  *
 #define rbgbccount tm_table[t_relocatable].tm_gbccount
 EXTER fixnum new_holepage,starting_hole_div,starting_relb_heap_mult;
 
-EXTER ufixnum recent_allocation,wait_on_abort;
+EXTER ulfixnum cumulative_allocation,recent_allocation;
+EXTER ufixnum wait_on_abort;
 EXTER double gc_alloc_min,mem_multiple,gc_page_min,gc_page_max;
 EXTER bool multiprocess_memory_pool;
 
--- gcl27-2.7.0.orig/lsp/gcl_callhash.lsp
+++ gcl27-2.7.0/lsp/gcl_callhash.lsp
@@ -41,10 +41,22 @@
     (mapc (lambda (x &aux (s (car x)) (cmp-sig (cdr x))(act-sig (car (sym-plist s))))
 	    (unless (eq sym s)
 	      (when act-sig
-		(unless (eq cmp-sig act-sig);Can be sig= if we don't hash
-		  (return-from needs-recompile (list (list sym s cmp-sig act-sig))))))) callees)
+		(unless (sig= cmp-sig act-sig);Can be sig= if we don't hash, or eq
+		  (return-from needs-recompile (list (list sym s cmp-sig act-sig)))))))
+	  callees)
     nil))
 
+(defun all-conflicts (&aux r q)
+  (do-all-symbols (sym q)
+    (let* ((plist (sym-plist sym))(callees (cadr plist)))
+      (mapc (lambda (x &aux (s (car x)) (cmp-sig (cdr x))(act-sig (car (sym-plist s))))
+	      (unless (eq sym s)
+		(when act-sig
+		  (unless (sig= cmp-sig act-sig);Can be sig= if we don't hash, or eq
+		    (pushnew sym (cadar (pushnew (list (car (pushnew (list s cmp-sig act-sig) r :test 'equal)) nil) q :key 'car :test 'equal)))))))
+	    callees)
+      nil)))
+
 (defun same-file-all-callees (x y fn)
 ;  (let ((z (remove-if-not (lambda (x) (equal (file x) fn)) (callees x)))) ;FIXME remove inline
   (let (z)
@@ -263,32 +275,34 @@
 	       (unless (callers-p s)
 		 (push s r))))))))))
 
-(defun do-pcl (x &aux (*sig-discovery-props* x))
-  (break)
-  (si::chdir "../pcl")
-  (mapc (lambda (x) (when (find-package x) (delete-package x))) '(:pcl :slot-accessor-name :iterate :walker))
-  (mapc 'delete-file (directory "*.o"))
-  (mapc 'load '("../clcs/package.lisp" "../clcs/myload1.lisp" "sys-package.lisp"))
-  (let ((*features* (remove :kcl *features*))) (load "../pcl/defsys.lisp"))
-  (setf (symbol-value (find-symbol "*DEFAULT-PATHNAME-EXTENSIONS*" (find-package :pcl))) (cons "lisp" "o")
-	(symbol-value (find-symbol "*PATHNAME-EXTENSIONS*" (find-package :pcl))) (cons "lisp" "o"))
-					;(load "sys-proclaim.lisp")
-  (setq compiler::*keep-gaz* t compiler::*tmp-dir* "" si::*disable-recompile* t)
-  (si::chdir "../pcl")
-  (funcall (find-symbol "COMPILE-PCL" :pcl)))
-
-(defun do-recomp (&rest excl &aux r *sig-discovery-props* *compile-verbose*)
-  (labels ((d (&aux (*sig-discovery* t)(q (remove-duplicates (mapcar 'car (mapcan 'needs-recompile r)))))
-	      (when q
-		(format t "~%Pass 1 signature discovery on ~s functions ..." (length q))
-		(mapc (lambda (x) (format t "~s " x) (compile x)) q) (d))))
-	  (do-all-symbols (s) (push s r))(d)
-	  (let* ((fl (mapcar 'car *sig-discovery-props*))
-		 (pclp (member-if (lambda (x) (eq (symbol-package x) (find-package :pcl))) fl))
-		 (fl (remove-duplicates (mapcar (lambda (x) (file x)) fl) :test 'string=))
-		 (fl (set-difference fl (cons "pcl_" excl) :test (lambda (x y) (search y x)))))
-	    (compiler::cdebug)
-	    (format t "~%Recompiling original source files ...")
-	    (mapc (lambda (x) (format t "~s~%" x) (compile-file x)) (remove nil fl))
-	    (when pclp
-	      (do-pcl *sig-discovery-props*)))))
+(defun gen-discovery-props (&aux (*sig-discovery* t) q)
+  (do-all-symbols (s) (let ((x (needs-recompile s))) (when x (pushnew (caar x) q))))
+  (when q
+    (format t "~%Pass 1 signature discovery on ~s functions ..." (length q))
+    (mapc (lambda (x) (format t "~s " x) (compile x)) q)
+    (gen-discovery-props)))
+
+(defun do-recomp2 (sp fl &aux *sig-discovery-props* *compile-verbose* r)
+  (gen-discovery-props)
+  (dolist (s (gen-all-ftype-symbols))
+    (let* ((f (file s))(f (if f (namestring (truename f)) ""));FIXME
+	   (sig (car (sym-plist s))))
+      (when (and sig (member f fl :test 'string=));e.g. fns in o/, interpreted, wrong-file
+	(push (list s sig) r))))
+  (write-sys-proclaims1 sp r))
+
+(defun do-recomp (&rest excl &aux *sig-discovery-props* *compile-verbose*)
+  (gen-discovery-props)
+  (let* ((fl (mapcar 'car *sig-discovery-props*))
+	 (fl (remove-duplicates (mapcar (lambda (x &aux (f (file x))) (when f (namestring f))) fl) :test 'string=))
+	 (fl (set-difference fl excl :test (lambda (x y) (search y x)))))
+    (compiler::cdebug)
+    (format t "~%Recompiling original source files ...")
+    (mapc (lambda (x) (format t "~s~%" x) (compile-file x)) (remove nil fl))))
+
+(defun gen-all-ftype-symbols (&aux r)
+  (do-all-symbols (s r)
+    (when (fboundp s)
+      (unless (or (macro-function s) (special-operator-p s))
+	(pushnew s r)))))
+
--- gcl27-2.7.0.orig/lsp/gcl_defstruct.lsp
+++ gcl27-2.7.0/lsp/gcl_defstruct.lsp
@@ -337,29 +337,26 @@
 	     (list ar (round-up pos (size-of t)) has-holes)
 	     ))))
 
-
-(defun tp-heads (tp0 &aux r)
-  (maphash (lambda (x y); (print x)
-	     (mapl (lambda (x) (unless (eq '* (car x)) (when (tp= tp0 (car x)) (push x r)))) (car x))
-	     (if (cmpt (cadr x))
-		 (mapl (lambda (x) (when (tp= tp0 (car x)) (push x r))) (cdadr x))
-		 (when (tp= tp0 (cadr x)) (push (cdr x) r))))
-	   *uniq-sig*)
-  r)
-
-(defun get-uniq-old-tp-heads (name);fixopt, others?
-  (when name
-    (cons (list* name (tp-heads (cmp-norm-tp name)))
-	  (get-uniq-old-tp-heads (sdata-name (sdata-includes (get name 's-data)))))))
-
 ;FIXME reconsider holding on to computed structure types
-(defun update-sdata-included (name &aux (i (sdata-includes (get name 's-data))))
-  (when i; (print (list 'foo (sdata-name i)))
-    (let ((r (get-uniq-old-tp-heads (sdata-name i))))
-      (pushnew name (s-data-included i))
-      (mapc (lambda (x &aux (tp1 (uniq-tp (cmp-norm-tp (pop x)))))
-	      (mapc (lambda (x) (setf (car x) tp1)) x))
-	    r))))
+(defun update-sdata-included (name &aux r (i (sdata-includes (get name 's-data))))
+  (when i
+    (let ((to (cmp-norm-tp `(and ,(sdata-name i) (not (or ,@(sdata-included i))))))
+	  (tn (cmp-norm-tp name))(ntn (cmp-norm-tp `(not ,name))))
+      (labels ((find-updates (x &aux (tp (car x)))
+		 (when (unless (tp<= #tstructure tp) (tp-and #tstructure tp))
+		   (let ((ntp (if (tp-and to tp) (tp-or tn tp) tp)));FIXME negative
+		     (unless (tp= tp ntp)
+		       (setf (car x) ntp)
+		       (push (cons tp ntp) r)))))
+	       (update-sig (x &aux (y (assoc (car x) r)))
+		 (when y (setf (car x) (cdr y)))))
+	(mapl #'find-updates (gethash (tsrch #tstructure) *uniq-tp*));FIXME more systematic
+	(mapl #'find-updates (gethash t *uniq-tp*))
+	(maphash (lambda (x y)
+		   (mapl #'update-sig (car x))
+		   (if (cmpt (cadr x)) (mapl #'update-sig (cdadr x)) (update-sig (cdr x))))
+		 *uniq-sig*)))
+    (pushnew name (s-data-included i))))
 
 ;FIXME function-src for all functions, sigs for constructor and copier
 (defun define-structure (name conc-name no-conc type named slot-descriptions copier
--- gcl27-2.7.0.orig/lsp/gcl_describe.lsp
+++ gcl27-2.7.0/lsp/gcl_describe.lsp
@@ -356,15 +356,15 @@
                *package*)))
 
     (cond ((special-operator-p symbol)
-           (doc1 (or (documentation symbol 'function) "")
+           (doc1 (or (real-documentation symbol 'function) "")
                  (if (macro-function symbol)
                      "[Special form and Macro]"
                      "[Special form]")))
           ((macro-function symbol)
-           (doc1 (or (documentation symbol 'function) "") "[Macro]"))
+           (doc1 (or (real-documentation symbol 'function) "") "[Macro]"))
           ((fboundp symbol)
            (doc1
-            (or (documentation symbol 'function)
+            (or (real-documentation symbol 'function)
                 (if (consp (setq x (function-lambda-expression (symbol-function symbol))))
                     (case (car x)
                           (lambda (format nil "~%Args: ~S" (cadr x)))
@@ -376,33 +376,33 @@
                           (t ""))
                     ""))
             "[Function]"))
-          ((setq x (documentation symbol 'function))
+          ((setq x (real-documentation symbol 'function))
            (doc1 x "[Macro or Function]")))
 
     (cond ((constantp symbol)
            (unless (and (eq (symbol-package symbol) (find-package "KEYWORD"))
-                        (null (documentation symbol 'variable)))
-             (doc1 (or (documentation symbol 'variable) "") "[Constant]")))
+                        (null (real-documentation symbol 'variable)))
+             (doc1 (or (real-documentation symbol 'variable) "") "[Constant]")))
           ((si:specialp symbol)
-           (doc1 (or (documentation symbol 'variable) "")
+           (doc1 (or (real-documentation symbol 'variable) "")
                  "[Special variable]"))
-          ((or (setq x (documentation symbol 'variable)) (boundp symbol))
+          ((or (setq x (real-documentation symbol 'variable)) (boundp symbol))
            (doc1 (or x "") "[Variable]")))
 
-    (cond ((setq x (documentation symbol 'type))
+    (cond ((setq x (real-documentation symbol 'type))
            (doc1 x "[Type]"))
           ((setq x (get symbol 'deftype-form))
            (let ((*package* (good-package)))
              (doc1 (format nil "~%Defined as: ~S~%See the doc of DEFTYPE." x)
                    "[Type]"))))
 
-    (cond ((setq x (documentation symbol 'structure))
+    (cond ((setq x (real-documentation symbol 'structure))
            (doc1 x "[Structure]"))
           ((setq x (get symbol 'defstruct-form))
            (doc1 (format nil "~%Defined as: ~S~%See the doc of DEFSTRUCT." x)
                  "[Structure]")))
 
-    (cond ((setq x (documentation symbol 'setf))
+    (cond ((setq x (real-documentation symbol 'setf))
            (doc1 x "[Setf]"))
           ((setq x (get symbol 'setf-update-fn))
            (let ((*package* (good-package)))
--- gcl27-2.7.0.orig/lsp/gcl_evalmacros.lsp
+++ gcl27-2.7.0/lsp/gcl_evalmacros.lsp
@@ -333,14 +333,16 @@
 (defmacro dotimes ((var form &optional val) &rest body
 		   &aux (s (sgen "DOTIMES"))(m (sgen "DOTIMES")))
   (declare (optimize (safety 1)))
-  `(let* ((,s (block nil ,form))(,m (min (max 0 ,s) most-positive-fixnum)))
+  `(let ((,s (block nil ,form)))
      (check-type ,s integer)
-     (do ((,var 0 (1+ ,var)))
-	 ((>= ,var ,m)
-	  (when (> ,s most-positive-fixnum)
-	    (do ((,var most-positive-fixnum (1+ ,var)))((>= ,var ,s)) ,@body))
-	  ,val);FIXME bbumps to non-negative-integer
-       ,@body)))
+     (let ((,m (min (max 0 ,s) most-positive-fixnum)))
+       (do ((,var 0 (1+ ,var)))
+	   ((>= ,var ,m)
+	    (when (> ,s most-positive-fixnum)
+	      (let ((,var ,var)) ,@body)
+	      (do ((,var (1+ most-positive-fixnum) (1+ ,var)))((>= ,var ,s)) ,@body))
+	    ,val)
+	 ,@body))))
 
 
 (defmacro declaim (&rest l)
@@ -523,37 +525,53 @@
 	 (d (cond (z '*)(y (remove '&optional d))(x `(returns-exactly ,@(cdr d)))(d))))
     (list a d)))
 
-(defun norm-possibly-unkown-type (type &aux (tp (cmp-norm-tp type)))
-  (flet ((fix (tp) (or tp t)))
+(defun norm-possibly-unknown-type (type &aux (tp (cmp-norm-tp type)))
+  (flet ((fix (tp) (or tp (when type t))))
     (cond ((cmpt tp) `(,(pop tp) ,@(mapcar #'fix tp)))
 	  ((fix tp)))))
 
 (defun proclaim-ftype (ftype var-list
 		       &aux  (sig (ftype-to-sig (cdr ftype)))
-			 (sig (uniq-sig (list (mapcar 'norm-possibly-unkown-type (car sig))
-					      (norm-possibly-unkown-type (cadr sig))))))
+			 (sig (uniq-sig (list (mapcar 'norm-possibly-unknown-type (car sig))
+					      (norm-possibly-unknown-type (cadr sig))))))
   (declare (optimize (safety 2)))
-  (mapc (lambda (x &aux (c (car (call x))))
-	  (cond (c (unless (sig= c sig)
-		     (warn "Ignoring proclaimed signature ~s on ~s, currently fbound to ~s~%"
-			   (readable-sig sig) x (readable-sig c))))
-		((setf (get x 'proclaimed-signature) sig))))
+  (mapc (lambda (x) (setf (get x 'proclaimed-signature) sig));(unless (car (call x)) )
 	var-list))
 
-(defun write-sys-proclaims (fn &rest package-list &aux
-				  (pl (mapcar 'find-package (or package-list (list-all-packages))))
-				  (h (make-hash-table :test 'eq))
-				  (*print-readably* t))
+(defun write-sys-proclaims (fn &rest string-list
+			    &aux (h (make-hash-table :test 'eq)) (*print-readably* t))
   (with-open-file
    (q fn :direction :output)
    (do-all-symbols
     (s)
-    (when (member (symbol-package s) pl)
-      (let ((x (sig s)))
+    (when (and (file s) (if string-list (member-if (lambda (x) (search x (namestring (file s)))) string-list) t))
+      (let ((x (or (car (sym-plist s)) (sig s))))
 	(when x
 	  (setf (gethash x h)
 		(adjoin s (gethash x h)))))))
    (maphash (lambda (x y)
-	      (print `(proclaim '(ftype (function ,(mapcar 'cmp-unnorm-tp (car x)) ,(cmp-unnorm-tp (cadr x))) ,@y))
-		     q))
+	      (flet ((ptp (x) (normalize-type (cmp-unnorm-tp x))))
+		(print `(proclaim '(ftype (function ,(mapcan (lambda (x) (if (eq x '*) '(&rest t) (list (ptp x)))) (car x))
+					   ,(cond ((cmpt (cadr x)) `(values ,@(when (eq (caadr x) 'values) `(&optional)) ,@(mapcar (lambda (x) (ptp x)) (cdadr x))))
+						  ((eq (cadr x) '*) '(values &rest t))
+						  ((ptp (cadr x)))))
+				    ,@y))
+		       q)))
 	    h)))
+
+
+(defun write-sys-proclaims1 (fn sl &aux (h (make-hash-table :test 'eq)) (*print-readably* t))
+  (with-open-file
+      (q fn :direction :output)
+    (dolist (s sl)
+      (let ((sym (car s))(sig (cadr s)))
+      (setf (gethash sig h) (adjoin sym (gethash sig h)))))
+    (flet ((ptp (x) (normalize-type (cmp-unnorm-tp x))))
+      (maphash (lambda (x y)
+		 (print `(proclaim '(ftype (function ,(mapcan (lambda (x) (if (eq x '*) '(&rest t) (list (ptp x)))) (car x))
+					    ,(cond ((cmpt (cadr x)) `(values ,@(when (eq (caadr x) 'values) `(&optional)) ,@(mapcar (lambda (x) (ptp x)) (cdadr x))))
+						   ((eq (cadr x) '*) '(values &rest t))
+						   ((ptp (cadr x)))))
+				     ,@y))
+			q))
+	       h))))
--- gcl27-2.7.0.orig/lsp/gcl_mislib.lsp
+++ gcl27-2.7.0/lsp/gcl_mislib.lsp
@@ -38,8 +38,9 @@
   (declare (optimize (safety 2)))
   (let ((real-start (gensym)) (real-end (gensym)) (gbc-time-start (gensym))
 	(gbc-time (gensym)) (x (gensym)) (run-start (gensym)) (run-end (gensym))
-	(child-run-start (gensym)) (child-run-end (gensym)))
-  `(let (,real-start ,real-end (,gbc-time-start (gbc-time)) ,gbc-time ,x)
+	(child-run-start (gensym)) (child-run-end (gensym))
+	(alloc-start (gensym)))
+  `(let (,real-start ,real-end (,gbc-time-start (gbc-time)) ,gbc-time ,x (,alloc-start (cumulative-allocation)))
      (setq ,real-start (get-internal-real-time))
      (multiple-value-bind (,run-start ,child-run-start) (get-internal-run-times)
        (gbc-time 0)
@@ -53,11 +54,13 @@
 		 "real time       : ~10,3F secs~%~
                   run-gbc time    : ~10,3F secs~%~
                   child run time  : ~10,3F secs~%~
-                  gbc time        : ~10,3F secs~%"
+                  gbc time        : ~10,3F secs~%~
+                  allocation      : ~10D Mbytes~%"
 		 (/ (- ,real-end ,real-start) internal-time-units-per-second)
 		 (/ (- (- ,run-end ,run-start) ,gbc-time) internal-time-units-per-second)
 		 (/ (- ,child-run-end ,child-run-start) internal-time-units-per-second)
-		 (/ ,gbc-time internal-time-units-per-second))))
+		 (/ ,gbc-time internal-time-units-per-second)
+		 (- (cumulative-allocation) ,alloc-start))))
        (values-list ,x))))
 
        
--- gcl27-2.7.0.orig/lsp/gcl_predlib.lsp
+++ gcl27-2.7.0/lsp/gcl_predlib.lsp
@@ -366,14 +366,11 @@
  (defmacro clh nil
   `(progn
      ,@(mapcar (lambda (x &aux (f (when (eq x 'find-class) `(&optional ep))) (z (intern (string-concatenate "SI-" (symbol-name x)))))
-		 `(let (y)
-		    (defun ,z (o ,@f &aux e (x ',x))
-		      (declare (notinline find-class));to enable recompile file in ansi image
-		      (cond ((and x (fboundp x) (fboundp 'classp))
-			     (prog1 (funcall x o ,@(cdr f))
-			       (fset ',z (symbol-function x))))
-			    ((setq e (get ',z 'early)) (values (funcall e o ,@(cdr f))))
-			    (y)))))
+		 `(defun ,z (o ,@f &aux e (x ',x) (fn (load-time-value nil)))
+		    (declare (notinline find-class));to enable recompile file in ansi image
+		    (setq fn (or fn (and (fboundp 'classp) (fboundp x) x)))
+		    (cond (fn (values (funcall fn o ,@(cdr f))))
+			  ((setq e (get ',z 'early)) (values (funcall e o ,@(cdr f)))))))
 	       '(classp class-precedence-list find-class class-name class-of class-direct-subclasses))
      (let (fun)
        (defun si-class-finalized-p (x)
--- gcl27-2.7.0.orig/lsp/gcl_serror.lsp
+++ gcl27-2.7.0/lsp/gcl_serror.lsp
@@ -4,22 +4,25 @@
 
 (macrolet 
  ((make-conditionp (condition &aux (n (intern (concatenate 'string (string condition) "P"))))
-		   `(defun ,n (x &aux (z (si-find-class ',condition nil)))
-		      (when (unless (symbolp z) z)
-			(funcall (setf (symbol-function ',n) (lambda (x) (typep x z))) x))))
+    `(defun ,n (x &aux (z (load-time-value nil)))
+       (setq z (or z (let ((x (si-find-class ',condition nil))) (unless (symbolp x) x))))
+       (when z (typep x z))))
   (make-condition-classp (class &aux (n (intern (concatenate 'string (string class) "-CLASS-P"))))
-			 `(defun ,n (x &aux (s (si-find-class 'standard-class nil)) (z (si-find-class ',class nil)))
-			    (when (and (unless (symbolp s) s) (unless (symbolp z) z))
-			      (funcall (setf (symbol-function ',n)
-					     (lambda (x &aux (x (if (symbolp x) (si-find-class x nil) x)))
-					       (when (and x (typep x s))
-						 (member z (si-cpl-or-nil x)))))
-				       x)))))
+    `(defun ,n (x &aux (s (load-time-value nil)) (z (load-time-value nil)))
+       (setq s (or s (let ((x (si-find-class 'standard-class nil))) (unless (symbolp x) x))))
+       (setq z (or z (let ((x (si-find-class ',class nil))) (unless (symbolp x) x))))
+       (when (and s z)
+	 (let ((x (if (symbolp x) (si-find-class x nil) x)))
+	   (when (and x (typep x s))
+	     (member z (si-cpl-or-nil x))))))))
   (make-conditionp condition)
   (make-conditionp warning)
   (make-condition-classp condition)
   (make-condition-classp simple-condition))
  
+(defun si-make-condition (tp &rest args &aux (z (load-time-value nil)))
+  (setq z (or z (when (fboundp 'make-condition) (symbol-function 'make-condition))))
+  (when z (values (apply z tp args))))
 
 (defun coerce-to-condition (datum arguments default-type function-name)
   (cond ((conditionp datum)
@@ -33,9 +36,9 @@
 		     :format-arguments (list datum function-name)))
 	 datum)
         ((condition-class-p datum)
-	 (apply #'make-condition datum arguments))
+	 (apply #'si-make-condition datum arguments))
         ((when (condition-class-p default-type) (or (stringp datum) (functionp datum)))
-	 (make-condition default-type :format-control datum :format-arguments arguments))
+	 (si-make-condition default-type :format-control datum :format-arguments arguments))
 	((coerce-to-string datum arguments))))
 
 (defvar *handler-clusters* nil)
--- gcl27-2.7.0.orig/lsp/gcl_subtypep.lsp
+++ gcl27-2.7.0/lsp/gcl_subtypep.lsp
@@ -442,8 +442,6 @@
 (defun std-ld (x &aux (c (pop x)))
   (cons c (if x (filter-included c (gen-get-included (car x))) '(t))))
 
-
-
 (defun std-matches (x)
   (lremove-if-not (lambda (y) (member (car y) x :test 'member :key 'cdr)) x))
 
--- gcl27-2.7.0.orig/lsp/gcl_type.lsp
+++ gcl27-2.7.0/lsp/gcl_type.lsp
@@ -781,8 +781,9 @@
 (defun sig= (s1 s2)
   (labels ((s= (l1 l2)
 	     (and (eql (length l1) (length l2))
-		  (every (lambda (x y) (if (or (symbolp x) (symbolp y)) (eq x y) (tp= x y))) l1 l2))))
-    (and (s= (car s1) (car s2))
-	 (if (or (cmpt (cadr s1)) (cmpt (cadr s2)))
-	     (and (cmpt (cadr s1)) (cmpt (cadr s2)) (s= (cadr s1) (cadr s2)))
-	     (s= (cdr s1) (cdr s2))))))
+		  (every (lambda (x y) (or (eq x y) (unless (or (symbolp x) (symbolp y)) (tp= x y)))) l1 l2))))
+    (or (eq s1 s2)
+	(and (s= (car s1) (car s2))
+	     (if (or (cmpt (cadr s1)) (cmpt (cadr s2)))
+		 (and (cmpt (cadr s1)) (cmpt (cadr s2)) (s= (cadr s1) (cadr s2)))
+		 (s= (cdr s1) (cdr s2)))))))
--- gcl27-2.7.0.orig/lsp/gcl_typep.lsp
+++ gcl27-2.7.0/lsp/gcl_typep.lsp
@@ -34,15 +34,15 @@
 (setf (get 'ibb 'cmp-inline) t)
 
 (defun sdata-includes (x)
-  (the (or s-data null) (*object (c-structure-self x) 4 nil nil)));FIXME s-data-name boostrap loop
+  (when x (the (or s-data null) (*object (c-structure-self x) 4 nil nil))));FIXME s-data-name boostrap loop
 (setf (get 'sdata-includes 'cmp-inline) t)
 (defun sdata-included (x)
-  (the proper-list (*object (c-structure-self x) 3 nil nil)));FIXME s-data-name boostrap loop
+  (when x (the proper-list (*object (c-structure-self x) 3 nil nil))));FIXME s-data-name boostrap loop
 (setf (get 'sdata-included 'cmp-inline) t)
 (defun sdata-name (x)
-  (the symbol (*object (c-structure-self x) 0 nil nil)));FIXME s-data-name boostrap loop
+  (when x (the symbol (*object (c-structure-self x) 0 nil nil))));FIXME s-data-name boostrap loop
 (defun sdata-type (x)
-  (the symbol (*object (c-structure-self x) 16 nil nil)));FIXME s-data-name boostrap loop
+  (when x (the symbol (*object (c-structure-self x) 16 nil nil))));FIXME s-data-name boostrap loop
 (setf (get 'sdata-name 'cmp-inline) t)
 
 (defun mss (o sn) (when o (or (eq (sdata-name o) sn) (mss (sdata-includes o) sn))))
--- gcl27-2.7.0.orig/makefile
+++ gcl27-2.7.0/makefile
@@ -122,7 +122,8 @@ $(PORTDIR)/saved_mod_gcl: $(PORTDIR)/sav
 	echo '(si::do-recomp)' | $@ && cd $(@D) && $(MAKE) $(@F)
 
 $(PORTDIR)/saved_pcl_gcl: $(PORTDIR)/saved_mod_gcl
-	(cd $(PCLDIR); $(MAKE) clean; $(MAKE) all)
+#	(cd $(PCLDIR); $(MAKE) clean; $(MAKE) all)
+	(cd $(PCLDIR); $(MAKE) remake-sys-files)
 	cd $(@D) && $(MAKE) $(@F)
 
 $(PORTDIR)/saved_ansi_gcl: $(PORTDIR)/saved_pcl_gcl
--- gcl27-2.7.0.orig/mod/sys-proclaim.lisp
+++ gcl27-2.7.0/mod/sys-proclaim.lisp
@@ -1,128 +0,0 @@
-
-(IN-PACKAGE "SYSTEM") 
-(PROCLAIM '(FTYPE (FUNCTION (T) (VALUES T T)) LISP::MAKE-KEYWORD)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T) FIXNUM) ANSI-LOOP::DUPLICATABLE-CODE-P)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T) *) LISP::VERIFY-KEYWORDS
-            LISP::DEFMACRO-ERROR ANSI-LOOP::LOOP-GET-COLLECTION-INFO)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T T T *) *) LISP::PARSE-DEFMACRO-LAMBDA-LIST
-            LISP::PARSE-DEFMACRO)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T T T T T T) *) LISP::PUSH-OPTIONAL-BINDING)) 
-(PROCLAIM '(FTYPE (FUNCTION (T T *) *) LISP::PARSE-BODY)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T) T) ANSI-LOOP::LOOP-SUM-COLLECTION
-            ANSI-LOOP::LOOP-TRANSLATE
-            ANSI-LOOP::LOOP-STANDARD-EXPANSION
-            ANSI-LOOP::PRINT-LOOP-UNIVERSE
-            ANSI-LOOP::LOOP-ANSI-FOR-EQUALS ANSI-LOOP::LOOP-FOR-ACROSS
-            ANSI-LOOP::LOOP-FOR-IN ANSI-LOOP::LOOP-FOR-ON
-            ANSI-LOOP::LOOP-FOR-BEING
-            ANSI-LOOP::HIDE-VARIABLE-REFERENCE
-            ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T *) T) ANSI-LOOP::LOOP-CHECK-DATA-TYPE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T *) T) ANSI-LOOP::ADD-LOOP-PATH
-            ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH
-            LISP::PUSH-LET-BINDING
-            ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH
-            ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH
-            ANSI-LOOP::LOOP-MAKE-VARIABLE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T T T T) T) LISP::DO-ARG-COUNT-ERROR
-            LISP::PUSH-SUB-LIST-BINDING)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T T) T) ANSI-LOOP::LOOP-FOR-ARITHMETIC)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T T T T T T T T T) T)
-            ANSI-LOOP::LOOP-SEQUENCER)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION NIL *) ANSI-LOOP::LOOP-DO-FOR
-            ANSI-LOOP::LOOP-POP-SOURCE ANSI-LOOP::LOOP-GET-FORM
-            ANSI-LOOP::LOOP-DISALLOW-AGGREGATE-BOOLEANS
-            ANSI-LOOP::LOOP-DISALLOW-ANONYMOUS-COLLECTORS)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION NIL T) ANSI-LOOP::LOOP-DO-FINALLY
-            ANSI-LOOP::LOOP-DO-DO ANSI-LOOP::LOOP-DO-RETURN
-            ANSI-LOOP::LOOP-DO-WITH ANSI-LOOP::LOOP-DO-REPEAT
-            ANSI-LOOP::LOOP-CONTEXT ANSI-LOOP::LOOP-ITERATION-DRIVER
-            ANSI-LOOP::LOOP-BIND-BLOCK
-            ANSI-LOOP::LOOP-GET-COMPOUND-FORM ANSI-LOOP::LOOP-GET-PROGN
-            ANSI-LOOP::LOOP-WHEN-IT-VARIABLE ANSI-LOOP::LOOP-DO-NAMED
-            ANSI-LOOP::LOOP-DO-INITIALLY)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (*) *) ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL
-            ANSI-LOOP::LOOP-OPTIONAL-TYPE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T) *) ANSI-LOOP::NAMED-VARIABLE
-            ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES
-            ANSI-LOOP::LOOP-LIST-STEP)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (*) T) ANSI-LOOP::MAKE-LOOP-PATH
-            ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE
-            ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL
-            ANSI-LOOP::LOOP-GENTEMP ANSI-LOOP::MAKE-LOOP-UNIVERSE
-            ANSI-LOOP::MAKE-LOOP-COLLECTOR
-            ANSI-LOOP::LOOP-EMIT-FINAL-VALUE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T) T) ANSI-LOOP::LOOP-COLLECTOR-CLASS
-            ANSI-LOOP::LOOP-COLLECTOR-HISTORY
-            ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS
-            ANSI-LOOP::LOOP-COLLECTOR-DTYPE
-            ANSI-LOOP::LOOP-COLLECTOR-DATA ANSI-LOOP::LOOP-PATH-NAMES
-            ANSI-LOOP::LOOP-LIST-COLLECTION
-            ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS
-            ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED
-            ANSI-LOOP::LOOP-PATH-FUNCTION
-            ANSI-LOOP::LOOP-PATH-USER-DATA
-            ANSI-LOOP::LOOP-MAXMIN-COLLECTION
-            ANSI-LOOP::LOOP-DO-THEREIS USER::MAKE-DEFPACKAGE-FORM
-            ANSI-LOOP::LOOP-COLLECTOR-NAME
-            ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE
-            ANSI-LOOP::LOOP-TYPED-INIT ANSI-LOOP::LOOP-MAKE-DESETQ
-            ANSI-LOOP::LOOP-MAKE-PSETQ
-            ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD
-            ANSI-LOOP::DESTRUCTURING-SIZE
-            ANSI-LOOP::SUBST-GENSYMS-FOR-NIL
-            ANSI-LOOP::LOOP-HACK-ITERATION ANSI-LOOP::LOOP-PSEUDO-BODY
-            ANSI-LOOP::LOOP-CONSTRUCT-RETURN ANSI-LOOP::LOOP-CONSTANTP
-            ANSI-LOOP::LOOP-EMIT-BODY
-            ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE
-            ANSI-LOOP::LOOP-MINIMAX-TYPE
-            ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE
-            ANSI-LOOP::LOOP-VARIABLE-P
-            ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE
-            ANSI-LOOP::LOOP-MINIMAX-OPERATIONS
-            ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA
-            ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS
-            ANSI-LOOP::LOOP-UNIVERSE-ITERATION-KEYWORDS
-            ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS
-            ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS
-            ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS
-            ANSI-LOOP::LOOP-UNIVERSE-TYPE-KEYWORDS
-            ANSI-LOOP::LOOP-UNIVERSE-ANSI
-            ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T *) *) ANSI-LOOP::LOOP-ERROR
-            ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T) *) ANSI-LOOP::ESTIMATE-CODE-SIZE-1
-            ANSI-LOOP::ESTIMATE-CODE-SIZE)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T *) T)
-            ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES
-            ANSI-LOOP::LOOP-WARN)) 
-(PROCLAIM
-    '(FTYPE (FUNCTION (T T) T) ANSI-LOOP::LOOP-TASSOC
-            ANSI-LOOP::HIDE-VARIABLE-REFERENCES
-            ANSI-LOOP::LOOP-DO-ALWAYS ANSI-LOOP::LOOP-DO-WHILE
-            ANSI-LOOP::LOOP-DO-IF LISP::KEYWORD-SUPPLIED-P
-            LISP::LOOKUP-KEYWORD ANSI-LOOP::LOOP-MAYBE-BIND-FORM
-            ANSI-LOOP::LOOP-BUILD-DESTRUCTURING-BINDINGS
-            ANSI-LOOP::LOOP-LOOKUP-KEYWORD ANSI-LOOP::LOOP-TMEMBER
-            ANSI-LOOP::LOOP-TEQUAL ANSI-LOOP::LOOP-DECLARE-VARIABLE
-            ANSI-LOOP::MAKE-LOOP-MINIMAX
-            ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION)) 
\ No newline at end of file
--- gcl27-2.7.0.orig/o/assignment.c
+++ gcl27-2.7.0/o/assignment.c
@@ -160,6 +160,8 @@ DEFUN("FUNCTION-NAME",object,fSfunction_
 
 DEFUN("FSET",object,fSfset,SI,2,2,NONE,OO,OO,OO,OO,(object sym,object function),"") {
 
+  object x;
+
   if (type_of(sym)!=t_symbol)
     sym=ifuncall1(sSfunid_to_sym,sym);
   
@@ -192,7 +194,8 @@ DEFUN("FSET",object,fSfset,SI,2,2,NONE,O
   sym->s.s_sfdef=NOT_SPECIAL;/*FIXME?*/
   if (function->fun.fun_plist!=Cnil) {
     function->fun.fun_plist->c.c_cdr->c.c_cdr->c.c_cdr->c.c_cdr->c.c_cdr->c.c_car=sym;/*FIXME*/
-    function->fun.fun_plist->c.c_cdr->c.c_cdr->c.c_cdr->c.c_car=sLAload_pathnameA->s.s_dbind;/*FIXME*/
+    x=function->fun.fun_plist->c.c_cdr->c.c_cdr->c.c_cdr->c.c_car;
+    function->fun.fun_plist->c.c_cdr->c.c_cdr->c.c_cdr->c.c_car=x==Cnil ? sLAload_pathnameA->s.s_dbind : x;/*FIXME*/
   }
   RETURN1(function);
 
--- gcl27-2.7.0.orig/o/cmpaux.c
+++ gcl27-2.7.0/o/cmpaux.c
@@ -628,31 +628,6 @@ gcl_init_or_load1(void (*fn)(void),const
 
 }
 
-DEFUN("INIT-CMP-ANON", object, fSinit_cmp_anon, SI, 0, 0,
-       NONE, OO, OO, OO,OO,(void),
-      "Initialize previously compiled and linked anonymous function from the \
-.text section of the running executable.  This function is inherently \
-dangerous, and is meant as a work-around to facilitate the production \
-of an ansi GCL image on systems which must currently link using \
-dlopen.  On such systems, it is imposible to compile and load \
-anonymous functions as part of the initialization sequence of the lisp \
-image, as is done in pcl, and preserve that function across a \
-save-system call.  The approach here is to provide a flag to GCL's \
-compile function which will direct the algorithm to forgo \
-recompilation and loading in favor of initialization via this \
-function.")
-{
-
-  int i;
-
-  i=gcl_init_cmp_anon();
-  if (i<0) 
-    FEerror("No such anonymous function",0);
-
-  return i ? Cnil : Ct;
-
-}
-
 object
 find_init_name1(char *s,unsigned len) {
 
--- gcl27-2.7.0.orig/o/gbc.c
+++ gcl27-2.7.0/o/gbc.c
@@ -1069,6 +1069,7 @@ GBC(enum type t) {
   }
 
   ngc_thresh=fix(sSAleaf_collection_thresholdA->s.s_dbind);
+  cumulative_allocation+=recent_allocation;
   recent_allocation=0;
 
   if (in_signal_handler && t == t_relocatable)
@@ -1301,6 +1302,13 @@ FFN(siLheap_report)(void) {
 #endif
 
 }  
+DEFUN("CUMULATIVE-ALLOCATION",object,fScumulative_allocation,SI,0,0,NONE,OO,OO,OO,OO,(void),"") {
+  ufixnum x=(cumulative_allocation+recent_allocation)>>20;
+  if ((fixnum)x>=0)
+    RETURN1(make_fixnum(x));
+  mpz_set_ui(MP(big_fixnum1),x);
+  RETURN1(replace_big(big_fixnum1));
+}
 
 DEFUN("ROOM-REPORT",object,fSroom_report,SI,0,0,NONE,OO,OO,OO,OO,(void),"") {
 
--- gcl27-2.7.0.orig/o/main.c
+++ gcl27-2.7.0/o/main.c
@@ -319,7 +319,7 @@ setup_maxpages(double scale) {
   resv_pages=available_pages/100;
   available_pages-=resv_pages;
 
-  recent_allocation=0;
+  cumulative_allocation=recent_allocation=0;
 
 }
 
--- gcl27-2.7.0.orig/pcl/gcl_pcl_boot.lisp
+++ gcl27-2.7.0/pcl/gcl_pcl_boot.lisp
@@ -644,14 +644,6 @@ work during bootstrapping.
     (let ((method (find-method (gdefinition name) qualifiers specializers)))
       (apply #'no-next-method (method-generic-function method) method args))))
 
-(defun generic-function-nreq (gf)
-  (let* ((arg-info (if (early-gf-p gf)
-                       (early-gf-arg-info gf)
-                       (gf-arg-info gf)));safe
-         (metatypes (arg-info-metatypes arg-info)))
-    (declare (list metatypes))
-    (length metatypes)))
-
 (defun %check-cnm-args (cnm-args orig-args method-name-declaration)
   (declare (optimize (speed 3) (safety 0) (debug 0))
            (type list cnm-args orig-args))
@@ -1335,6 +1327,14 @@ work during bootstrapping.
        (unless (equal ,pos ,valsym)
 	 (setf ,pos ,valsym)))))
 
+(defun generic-function-nreq (gf)
+  (let* ((arg-info (if (early-gf-p gf)
+                       (early-gf-arg-info gf)
+                       (gf-arg-info gf)));safe
+         (metatypes (arg-info-metatypes arg-info)))
+    (declare (list metatypes))
+    (length metatypes)))
+
 (defun set-arg-info (gf &key new-method (lambda-list nil lambda-list-p)
 			argument-precedence-order)
   (let* ((arg-info (if (eq *boot-state* 'complete)
@@ -2121,7 +2121,7 @@ work during bootstrapping.
 		 ,gensyms 
 		 ,(caddr form)
 		 .,(reverse (mapcar (lambda (v g) `(setf ,v ,g)) vars gensyms))))))
-	  ((eq (car form) 'conditions::restart-case)
+	  ((eq (car form) 'restart-case)
 	   (let* ((nf (cadr form))
 		  (nf (let ((y (assoc nf specs)))
 			(if (and y (eq (cadr y) (variable-lexical-p nf env))) (walker::macroexpand-all (caddr y) env) nf))))
--- gcl27-2.7.0.orig/pcl/gcl_pcl_impl_low.lisp
+++ gcl27-2.7.0/pcl/gcl_pcl_impl_low.lisp
@@ -63,7 +63,7 @@
 	(env (make-list funcallable-instance-closure-size :initial-element nil)))
     (si::set-function-environment fin env)
     (c-set-t-tt fin (logior 1 (c-t-tt fin)))
-    fin))
+    (the si::funcallable-std-instance fin)))
 
 (defun funcallable-instance-p (x) (typep x 'funcallable-std-instance))
 (defun std-instance-p (x) (typep x 'std-instance))
@@ -168,33 +168,20 @@
 
 (defun renew-sys-files nil
   ;; packages:
-  (compiler::get-packages "sys-package.lisp")
+  (compiler::get-packages-ansi
+   '(:walker :iterate :pcl :slot-accessor-name)
+   "sys-package.lisp")
   (with-open-file (st "sys-package.lisp"
-			  :direction :output
-			  :if-exists :append)
-	(format st "(lisp::in-package \"SI\")
+		      :direction :output
+		      :if-exists :append)
+		  (format st "(lisp::in-package \"SI\")
 (export '(%structure-name
           %compiled-function-name
           %set-compiled-function-name))
 (in-package \"PCL\")
 "))
 
-  ;; proclaims
-  (compiler::make-all-proclaims "*.fn")
-  (with-open-file (st "sys-proclaim.lisp"
-		      :direction :output
-		      :if-exists :append)
-    (format st "~%(IN-PACKAGE \"PCL\")~%")
-    (print
-     `(dolist (v ',
-     
-	       (sloop::sloop for v in-package "PCL"
-			     when (get v 'compiler::proclaimed-closure)
-			     collect v))
-	(setf (get v 'compiler::proclaimed-closure) t))
-     st)
-    (format st "~%")
-))
+  (si::do-recomp2 "sys-proclaim.lisp" (mapcar 'namestring (directory "*.*p"))))
 
 	
 		 
--- gcl27-2.7.0.orig/pcl/gcl_pcl_vector.lisp
+++ gcl27-2.7.0/pcl/gcl_pcl_vector.lisp
@@ -237,7 +237,7 @@
 				     2)))))
     (or (probe-cache cache pv-wrappers)
 	(let* ((pv (compute-pv slot-name-lists pv-wrappers))
-	       (calls (compute-calls call-list pv-wrappers))
+	       (calls '#());(compute-calls call-list pv-wrappers)
 	       (pv-cell (cons pv calls))
 	       (new-cache (fill-cache cache pv-wrappers pv-cell)))
 	  (unless (eq new-cache cache)
--- gcl27-2.7.0.orig/pcl/makefile
+++ gcl27-2.7.0/pcl/makefile
@@ -4,10 +4,7 @@
 
 FILES:=$(shell ls -1 gcl_*.lisp | sed 's,\.lisp,,1')
 
-GFILES1:= 0 1 2 3 4 5 6 7 #8
-GFILES:=$(addprefix gcl_pcl_gazonk,$(GFILES1))
-
-AFILES:=$(FILES) $(GFILES)
+AFILES:=$(FILES)
 
 SETUP='(load "../clcs/package.lisp")(load "../clcs/myload1.lisp")(load "sys-package.lisp")' \
 	'(setq *features* (delete (quote :kcl) *features*))'\
@@ -20,7 +17,8 @@ SETUP='(load "../clcs/package.lisp")(loa
 	'(setq compiler::*default-c-file* t)'\
 	'(setq compiler::*default-data-file* t)'\
 	'(setq compiler::*default-system-p* t)' \
-	'(setq compiler::*keep-gaz* t compiler::*tmp-dir* "" si::*disable-recompile* t)'
+	'(setq compiler::*assert-ftype-proclamations* t)' \
+	'(setq compiler::*tmp-dir* "" si::*disable-recompile* t)'
 
 LISP?=../unixport/saved_mod_gcl
 APPEND=../xbin/append
@@ -40,41 +38,32 @@ saved_gcl_pcl: $(LISP)
 	echo $(SETUP) '(pcl::load-pcl)(si::save-system "$@")' | $< $(LISPFLAGS)
 
 $(addsuffix .c,$(AFILES)) $(addsuffix .data,$(AFILES))\
-	$(addsuffix .h,$(AFILES)) $(addsuffix .lsp,$(GFILES)): \
+	$(addsuffix .h,$(AFILES)): \
 	$(addsuffix .lisp,$(FILES))
-	rm -f *.o *gazonk*
 	cp ../h/cmpinclude.h .
 	echo ${SETUP} '(pcl::compile-pcl)' | $(LISP)
-	rm *gazonk*.o
-#	touch gcl_pcl_methods.c # FIXME workaround for -g -Os gcc bug
-	for i in gazonk* ; do \
-		j=$$(echo $$i | sed 's,\..*$$,,1');k="gazonk$$(echo $$j | cut -f3 -d\_)";\
-		l=$$(echo $$i | sed 's,^.*\.,,1');\
-		cat $$i | sed   -e "s,$$j\.h,gcl_pcl_$$k.h,1" \
-				-e "s,init_.*$$j(),init_gcl_pcl_$$k(),g" >gcl_pcl_$$k.$$l && rm $$i; done
 
 %.o: %.c %.h %.data
 	$(CC) $(CFLAGS) -c $< -o $@
 	../xbin/append $*.data $@
 
 clean:
-	rm -f *.o *.fn *.exe *.dll saved_gcl_pcl cmpinclude.h *.c *.h *.data *gazonk*
+	rm -f *.o *.fn *.exe *.dll saved_gcl_pcl cmpinclude.h *.c *.h *.data
 
 
 # remake the sys-package.lisp and sys-proclaim.lisp files
 # Those files may be empty on a first build.
 remake-sys-files:
-	rm -f *.o *gazonk*
-	cp ../h/cmpinclude.h .
-	echo ${SETUP} '(load "../cmpnew/gcl_collectfn.lsp")(compiler::emit-fn t)' \
-		'(pcl::compile-pcl)' | $(LISP) ../unixport/ $(LISPFLAGS)
-	echo ${SETUP} '(load "../cmpnew/gcl_collectfn.lsp") '\
-		'(pcl::load-pcl)(in-package "PCL")(renew-sys-files)' | \
-		$(LISP) ../unixport/ $(LISPFLAGS) 
-	cp sys-proclaim.lisp xxx
-	cat xxx | sed -e "s/COMPILER::CMP-ANON//g" > sys-proclaim.lisp
-	rm xxx
-
+	$(MAKE) clean
+	rm -f sys-proclaim.lisp
+	touch sys-proclaim.lisp
+	$(MAKE)
+	echo $(SETUP) '(pcl::load-pcl)(load "../cmpnew/gcl_collectfn.lsp")(pcl::renew-sys-files)' \
+		| $(LISP) ../unixport/ $(LISPFLAGS)
+	$(MAKE) clean
+	$(MAKE)
+	echo $(SETUP) '(pcl::load-pcl)(si::all-conflicts)' \
+		| $(LISP) ../unixport/ $(LISPFLAGS)
 
 tar:
 	$(MAKE) -f makefile.gcl  tar1 DIR=`pwd`
--- gcl27-2.7.0.orig/pcl/sys-package.lisp
+++ gcl27-2.7.0/pcl/sys-package.lisp
@@ -1,7 +1,4774 @@
-;; Copyright (C) 2024 Camm Maguire
-(make-package :slot-accessor-name :use '(:cl) :nicknames '(:s-a-n))
-(make-package :walker :use '(:cl))
-(make-package :iterate :use '(:cl :walker))
-(make-package :pcl :use '(:cl :iterate :walker :s))
-(import 'si::(clines defentry defcfun object void int double non-negative-fixnum macro memq seqind structurep structure-def structure-ref std-instance funcallable-std-instance) :pcl)
-(import 'si::(macro) :walker)
+
+
+;;; 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 ITERATE of type ESTABLISH
+(COMMON-LISP::UNLESS
+ (COMMON-LISP::FIND-PACKAGE "ITERATE")
+ (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("WALKER" "COMMON-LISP")))
+
+;;; Definitions for package PCL of type ESTABLISH
+(COMMON-LISP::UNLESS
+ (COMMON-LISP::FIND-PACKAGE "PCL")
+ (COMMON-LISP::MAKE-PACKAGE
+  "PCL" :USE '("S" "WALKER" "ITERATE" "COMMON-LISP")))
+
+;;; Definitions for package WALKER of type EXPORT
+(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")
+(COMMON-LISP::EXPORT
+ '(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")
+
+;;; 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
+   ITERATE::MINIMIZING ITERATE::PLIST-ELEMENTS ITERATE::ITERATE*
+   ITERATE::MAXIMIZING ITERATE::LIST-TAILS ITERATE::*ITERATE-WARNINGS*
+   ITERATE::GATHERING ITERATE::EACHTIME ITERATE::ELEMENTS
+   ITERATE::GATHER ITERATE::LIST-ELEMENTS ITERATE::WHILE
+   ITERATE::ITERATE ITERATE::UNTIL ITERATE::JOINING ITERATE::COLLECTING
+   ITERATE::WITH-GATHERING ITERATE::INTERVAL)
+ "ITERATE")
+(COMMON-LISP::EXPORT
+ '(ITERATE::SUMMING
+   ITERATE::MINIMIZING ITERATE::PLIST-ELEMENTS ITERATE::ITERATE*
+   ITERATE::MAXIMIZING ITERATE::LIST-TAILS ITERATE::*ITERATE-WARNINGS*
+   ITERATE::GATHERING ITERATE::EACHTIME ITERATE::ELEMENTS
+   ITERATE::GATHER ITERATE::LIST-ELEMENTS ITERATE::WHILE
+   ITERATE::ITERATE ITERATE::UNTIL ITERATE::JOINING ITERATE::COLLECTING
+   ITERATE::WITH-GATHERING ITERATE::INTERVAL)
+ "ITERATE")
+
+;;; Definitions for package PCL of type EXPORT
+(COMMON-LISP::IMPORT
+ '(PCL::CLASS-PRECEDENCE-LIST
+   PCL::SLOT-DEFINITION PCL::COMPUTE-APPLICABLE-METHODS-USING-CLASSES
+   PCL::SLOT-DEFINITION-WRITERS COMMON-LISP::CLASS-OF
+   COMMON-LISP::NO-APPLICABLE-METHOD PCL::STANDARD-WRITER-METHOD
+   PCL::ENSURE-CLASS-USING-CLASS COMMON-LISP::ENSURE-GENERIC-FUNCTION
+   PCL::FIND-METHOD-COMBINATION PCL::UPDATE-DEPENDENT
+   PCL::MAP-DEPENDENTS COMMON-LISP::SLOT-MISSING PCL::SPECIALIZER
+   COMMON-LISP::CALL-NEXT-METHOD
+   PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS
+   PCL::SLOT-MAKUNBOUND-USING-CLASS
+   COMMON-LISP::MAKE-INSTANCES-OBSOLETE PCL::INTERN-EQL-SPECIALIZER
+   PCL::REMOVE-DIRECT-SUBCLASS PCL::METHOD-GENERIC-FUNCTION
+   COMMON-LISP::METHOD-QUALIFIERS PCL::FUNCALLABLE-STANDARD-CLASS
+   PCL::EXTRACT-LAMBDA-LIST COMMON-LISP::STANDARD-CLASS
+   COMMON-LISP::PRINT-OBJECT COMMON-LISP::STRUCTURE-CLASS
+   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION
+   PCL::GENERIC-FUNCTION-DECLARATIONS COMMON-LISP::MAKE-INSTANCE
+   PCL::METHOD-LAMBDA-LIST COMMON-LISP::DEFGENERIC
+   PCL::REMOVE-DIRECT-METHOD PCL::STANDARD-DIRECT-SLOT-DEFINITION
+   PCL::GENERIC-FUNCTION-METHODS PCL::VALIDATE-SUPERCLASS
+   COMMON-LISP::REINITIALIZE-INSTANCE COMMON-LISP::STANDARD-METHOD
+   PCL::STANDARD-ACCESSOR-METHOD PCL::FUNCALLABLE-STANDARD-INSTANCE
+   COMMON-LISP::FUNCTION-KEYWORDS COMMON-LISP::STANDARD
+   COMMON-LISP::FIND-METHOD PCL::EXTRACT-SPECIALIZER-NAMES
+   COMMON-LISP::INITIALIZE-INSTANCE PCL::GENERIC-FLET
+   COMMON-LISP::SLOT-UNBOUND PCL::STANDARD-INSTANCE
+   PCL::SLOT-DEFINITION-TYPE PCL::COMPUTE-EFFECTIVE-METHOD
+   COMMON-LISP::ALLOCATE-INSTANCE COMMON-LISP::SYMBOL-MACROLET
+   COMMON-LISP::GENERIC-FUNCTION
+   PCL::GENERIC-FUNCTION-METHOD-COMBINATION
+   PCL::SPECIALIZER-DIRECT-METHODS PCL::ADD-DIRECT-SUBCLASS
+   PCL::WRITER-METHOD-CLASS PCL::SLOT-DEFINITION-INITARGS
+   PCL::METHOD-SPECIALIZERS PCL::GENERIC-FUNCTION-METHOD-CLASS
+   COMMON-LISP::ADD-METHOD COMMON-LISP::WITH-ACCESSORS
+   PCL::SLOT-DEFINITION-ALLOCATION PCL::SLOT-DEFINITION-INITFUNCTION
+   PCL::SLOT-DEFINITION-LOCATION PCL::ADD-DIRECT-METHOD
+   COMMON-LISP::SLOT-BOUNDP PCL::EQL-SPECIALIZER
+   COMMON-LISP::SHARED-INITIALIZE
+   COMMON-LISP::STANDARD-GENERIC-FUNCTION
+   PCL::ACCESSOR-METHOD-SLOT-DEFINITION PCL::SLOT-BOUNDP-USING-CLASS
+   PCL::ADD-DEPENDENT PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTION
+   PCL::WITH-ADDED-METHODS PCL::COMPUTE-CLASS-PRECEDENCE-LIST
+   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS PCL::REMOVE-DEPENDENT
+   COMMON-LISP::NEXT-METHOD-P PCL::GENERIC-FUNCTION-NAME
+   COMMON-LISP::SLOT-VALUE PCL::EFFECTIVE-SLOT-DEFINITION
+   PCL::CLASS-FINALIZED-P PCL::COMPUTE-DISCRIMINATING-FUNCTION
+   COMMON-LISP::STANDARD-OBJECT PCL::CLASS-DEFAULT-INITARGS
+   PCL::CLASS-DIRECT-SLOTS PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS
+   COMMON-LISP::BUILT-IN-CLASS COMMON-LISP::NO-NEXT-METHOD
+   COMMON-LISP::SLOT-MAKUNBOUND PCL::STANDARD-READER-METHOD
+   PCL::GENERIC-FUNCTION-LAMBDA-LIST
+   PCL::GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
+   COMMON-LISP::INVALID-METHOD-ERROR
+   COMMON-LISP::METHOD-COMBINATION-ERROR COMMON-LISP::SLOT-EXISTS-P
+   PCL::FINALIZE-INHERITANCE PCL::SLOT-DEFINITION-NAME
+   PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION PCL::COMPUTE-SLOTS
+   PCL::CLASS-SLOTS PCL::EFFECTIVE-SLOT-DEFINITION-CLASS
+   PCL::STANDARD-INSTANCE-ACCESS COMMON-LISP::WITH-SLOTS
+   PCL::DIRECT-SLOT-DEFINITION COMMON-LISP::DEFINE-METHOD-COMBINATION
+   PCL::MAKE-METHOD-LAMBDA PCL::ENSURE-CLASS
+   PCL::DIRECT-SLOT-DEFINITION-CLASS COMMON-LISP::MAKE-LOAD-FORM
+   PCL::METHOD-FUNCTION PCL::STANDARD-SLOT-DEFINITION
+   COMMON-LISP::CHANGE-CLASS COMMON-LISP::DEFMETHOD
+   COMMON-LISP::UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
+   COMMON-LISP::UPDATE-INSTANCE-FOR-REDEFINED-CLASS
+   PCL::FORWARD-REFERENCED-CLASS PCL::SLOT-DEFINITION-INITFORM
+   COMMON-LISP::REMOVE-METHOD PCL::READER-METHOD-CLASS
+   COMMON-LISP::CALL-METHOD PCL::CLASS-PROTOTYPE
+   COMMON-LISP::CLASS-NAME COMMON-LISP::FIND-CLASS
+   COMMON-LISP::DEFCLASS COMMON-LISP::COMPUTE-APPLICABLE-METHODS
+   COMMON-LISP::DESCRIBE-OBJECT PCL::SLOT-VALUE-USING-CLASS
+   COMMON-LISP::METHOD-COMBINATION PCL::EQL-SPECIALIZER-INSTANCE
+   PCL::GENERIC-LABELS COMMON-LISP::METHOD PCL::SLOT-DEFINITION-READERS
+   PCL::CLASS-DIRECT-DEFAULT-INITARGS PCL::CLASS-DIRECT-SUBCLASSES
+   PCL::CLASS-DIRECT-SUPERCLASSES
+   PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION)
+ "PCL")
+(COMMON-LISP::EXPORT
+ '(PCL::CLASS-PRECEDENCE-LIST
+   PCL::SLOT-DEFINITION PCL::COMPUTE-APPLICABLE-METHODS-USING-CLASSES
+   PCL::SLOT-DEFINITION-WRITERS COMMON-LISP::CLASS-OF
+   COMMON-LISP::NO-APPLICABLE-METHOD PCL::STANDARD-WRITER-METHOD
+   PCL::ENSURE-CLASS-USING-CLASS COMMON-LISP::ENSURE-GENERIC-FUNCTION
+   PCL::FIND-METHOD-COMBINATION PCL::UPDATE-DEPENDENT
+   PCL::MAP-DEPENDENTS COMMON-LISP::SLOT-MISSING PCL::SPECIALIZER
+   COMMON-LISP::CALL-NEXT-METHOD
+   PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS
+   PCL::SLOT-MAKUNBOUND-USING-CLASS
+   COMMON-LISP::MAKE-INSTANCES-OBSOLETE PCL::INTERN-EQL-SPECIALIZER
+   PCL::REMOVE-DIRECT-SUBCLASS PCL::METHOD-GENERIC-FUNCTION
+   COMMON-LISP::METHOD-QUALIFIERS PCL::FUNCALLABLE-STANDARD-CLASS
+   PCL::EXTRACT-LAMBDA-LIST COMMON-LISP::STANDARD-CLASS
+   COMMON-LISP::PRINT-OBJECT COMMON-LISP::STRUCTURE-CLASS
+   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION
+   PCL::GENERIC-FUNCTION-DECLARATIONS COMMON-LISP::MAKE-INSTANCE
+   PCL::METHOD-LAMBDA-LIST COMMON-LISP::DEFGENERIC
+   PCL::REMOVE-DIRECT-METHOD PCL::STANDARD-DIRECT-SLOT-DEFINITION
+   PCL::GENERIC-FUNCTION-METHODS PCL::VALIDATE-SUPERCLASS
+   COMMON-LISP::REINITIALIZE-INSTANCE COMMON-LISP::STANDARD-METHOD
+   PCL::STANDARD-ACCESSOR-METHOD PCL::FUNCALLABLE-STANDARD-INSTANCE
+   COMMON-LISP::FUNCTION-KEYWORDS COMMON-LISP::STANDARD
+   COMMON-LISP::FIND-METHOD PCL::EXTRACT-SPECIALIZER-NAMES
+   COMMON-LISP::INITIALIZE-INSTANCE PCL::GENERIC-FLET
+   COMMON-LISP::SLOT-UNBOUND PCL::STANDARD-INSTANCE
+   PCL::SLOT-DEFINITION-TYPE PCL::COMPUTE-EFFECTIVE-METHOD
+   COMMON-LISP::ALLOCATE-INSTANCE COMMON-LISP::SYMBOL-MACROLET
+   COMMON-LISP::GENERIC-FUNCTION
+   PCL::GENERIC-FUNCTION-METHOD-COMBINATION
+   PCL::SPECIALIZER-DIRECT-METHODS PCL::ADD-DIRECT-SUBCLASS
+   PCL::WRITER-METHOD-CLASS PCL::SLOT-DEFINITION-INITARGS
+   PCL::METHOD-SPECIALIZERS PCL::GENERIC-FUNCTION-METHOD-CLASS
+   COMMON-LISP::ADD-METHOD COMMON-LISP::WITH-ACCESSORS
+   PCL::SLOT-DEFINITION-ALLOCATION PCL::SLOT-DEFINITION-INITFUNCTION
+   PCL::SLOT-DEFINITION-LOCATION PCL::ADD-DIRECT-METHOD
+   COMMON-LISP::SLOT-BOUNDP PCL::EQL-SPECIALIZER
+   COMMON-LISP::SHARED-INITIALIZE
+   COMMON-LISP::STANDARD-GENERIC-FUNCTION
+   PCL::ACCESSOR-METHOD-SLOT-DEFINITION PCL::SLOT-BOUNDP-USING-CLASS
+   PCL::ADD-DEPENDENT PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTION
+   PCL::WITH-ADDED-METHODS PCL::COMPUTE-CLASS-PRECEDENCE-LIST
+   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS PCL::REMOVE-DEPENDENT
+   COMMON-LISP::NEXT-METHOD-P PCL::GENERIC-FUNCTION-NAME
+   COMMON-LISP::SLOT-VALUE PCL::EFFECTIVE-SLOT-DEFINITION
+   PCL::CLASS-FINALIZED-P PCL::COMPUTE-DISCRIMINATING-FUNCTION
+   COMMON-LISP::STANDARD-OBJECT PCL::CLASS-DEFAULT-INITARGS
+   PCL::CLASS-DIRECT-SLOTS PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS
+   COMMON-LISP::BUILT-IN-CLASS COMMON-LISP::NO-NEXT-METHOD
+   COMMON-LISP::SLOT-MAKUNBOUND PCL::STANDARD-READER-METHOD
+   PCL::GENERIC-FUNCTION-LAMBDA-LIST
+   PCL::GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
+   COMMON-LISP::INVALID-METHOD-ERROR
+   COMMON-LISP::METHOD-COMBINATION-ERROR COMMON-LISP::SLOT-EXISTS-P
+   PCL::FINALIZE-INHERITANCE PCL::SLOT-DEFINITION-NAME
+   PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION PCL::COMPUTE-SLOTS
+   PCL::CLASS-SLOTS PCL::EFFECTIVE-SLOT-DEFINITION-CLASS
+   PCL::STANDARD-INSTANCE-ACCESS COMMON-LISP::WITH-SLOTS
+   PCL::DIRECT-SLOT-DEFINITION COMMON-LISP::DEFINE-METHOD-COMBINATION
+   PCL::MAKE-METHOD-LAMBDA PCL::ENSURE-CLASS
+   PCL::DIRECT-SLOT-DEFINITION-CLASS COMMON-LISP::MAKE-LOAD-FORM
+   PCL::METHOD-FUNCTION PCL::STANDARD-SLOT-DEFINITION
+   COMMON-LISP::CHANGE-CLASS COMMON-LISP::DEFMETHOD
+   COMMON-LISP::UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
+   COMMON-LISP::UPDATE-INSTANCE-FOR-REDEFINED-CLASS
+   PCL::FORWARD-REFERENCED-CLASS PCL::SLOT-DEFINITION-INITFORM
+   COMMON-LISP::REMOVE-METHOD PCL::READER-METHOD-CLASS
+   COMMON-LISP::CALL-METHOD PCL::CLASS-PROTOTYPE
+   COMMON-LISP::CLASS-NAME COMMON-LISP::FIND-CLASS
+   COMMON-LISP::DEFCLASS COMMON-LISP::COMPUTE-APPLICABLE-METHODS
+   COMMON-LISP::DESCRIBE-OBJECT PCL::SLOT-VALUE-USING-CLASS
+   COMMON-LISP::METHOD-COMBINATION PCL::EQL-SPECIALIZER-INSTANCE
+   PCL::GENERIC-LABELS COMMON-LISP::METHOD PCL::SLOT-DEFINITION-READERS
+   PCL::CLASS-DIRECT-DEFAULT-INITARGS PCL::CLASS-DIRECT-SUBCLASSES
+   PCL::CLASS-DIRECT-SUPERCLASSES
+   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")
+(COMMON-LISP::IMPORT
+ '(COMMON-LISP::EXP
+   COMMON-LISP::DEFVAR COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
+   COMMON-LISP::DISASSEMBLE COMMON-LISP::DELETE-IF
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OWNER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot WRITER|
+   COMMON-LISP::CONCATENATED-STREAM-STREAMS COMMON-LISP::CLASS-OF
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot READER|
+   COMMON-LISP::NSUBST-IF-NOT COMMON-LISP::CIS COMMON-LISP::LOGAND
+   COMMON-LISP::BIT-EQV COMMON-LISP::MAKE-INSTANCES-OBSOLETE
+   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot WRITER|
+   COMMON-LISP::RANDOM COMMON-LISP::COPY-LIST
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot WRITER|
+   COMMON-LISP::KEYWORDP 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
+   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
+   COMMON-LISP::COSH COMMON-LISP::NTHCDR
+   COMMON-LISP::GET-UNIVERSAL-TIME COMMON-LISP::YES-OR-NO-P
+   COMMON-LISP::READ-LINE COMMON-LISP::LET* COMMON-LISP::PATHNAME-TYPE
+   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot READER|
+   COMMON-LISP::FLOAT-PRECISION COMMON-LISP::PROG*
+   COMMON-LISP::SYMBOL-NAME COMMON-LISP::LOG COMMON-LISP::OR
+   COMMON-LISP::PACKAGE-SHADOWING-SYMBOLS COMMON-LISP::BREAK
+   COMMON-LISP::STRUCTURE-OBJECT
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot WRITER| COMMON-LISP::ROTATEF
+   COMMON-LISP::SQRT COMMON-LISP::CONS COMMON-LISP::NSUBST-IF
+   COMMON-LISP::UNWIND-PROTECT COMMON-LISP::CONSP
+   COMMON-LISP::FLOAT-SIGN COMMON-LISP::SOME COMMON-LISP::MAPC
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot READER| COMMON-LISP::SETF
+   COMMON-LISP::CEILING COMMON-LISP::&BODY COMMON-LISP::CDAR
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot BOUNDP| COMMON-LISP::STANDARD
+   COMMON-LISP::MAKE-LIST
+   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot WRITER|
+   COMMON-LISP::RATIONALP COMMON-LISP::SET-DISPATCH-MACRO-CHARACTER
+   COMMON-LISP::GET-DISPATCH-MACRO-CHARACTER COMMON-LISP::CHECK-TYPE
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot BOUNDP|
+   COMMON-LISP::MAKE-STRING-INPUT-STREAM
+   COMMON-LISP::MAKE-STRING-OUTPUT-STREAM
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER REPEATABLE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER DEF slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot READER|
+   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 SLOT-ACCESSOR-NAME::|PCL METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER REPEATABLE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER DEF slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot WRITER|
+   COMMON-LISP::DEFINE-COMPILER-MACRO COMMON-LISP::PROGN
+   COMMON-LISP::PUSHNEW COMMON-LISP::CHAR=
+   COMMON-LISP::MAKE-ECHO-STREAM COMMON-LISP::BIT-AND
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot BOUNDP|
+   COMMON-LISP::EXPORT COMMON-LISP::EQ COMMON-LISP::SOFTWARE-TYPE
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot BOUNDP|
+   COMMON-LISP::LOGTEST COMMON-LISP::LIST-ALL-PACKAGES
+   COMMON-LISP::DEFTYPE COMMON-LISP::GETF
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot BOUNDP|
+   COMMON-LISP::ROW-MAJOR-AREF COMMON-LISP::TYPECASE
+   COMMON-LISP::HASH-TABLE-TEST COMMON-LISP::USER-HOMEDIR-PATHNAME
+   COMMON-LISP::SYMBOL-PACKAGE COMMON-LISP::BOOLEAN
+   COMMON-LISP::HOST-NAMESTRING
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot BOUNDP|
+   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 SLOT-ACCESSOR-NAME::|PCL INITARGS slot BOUNDP|
+   COMMON-LISP::BIT-VECTOR COMMON-LISP::SEARCH
+   COMMON-LISP::STREAM-ELEMENT-TYPE COMMON-LISP::POP
+   COMMON-LISP::SLOT-UNBOUND COMMON-LISP::GO COMMON-LISP::LIST
+   COMMON-LISP::*LOAD-PRINT* 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/=
+   COMMON-LISP::REMPROP COMMON-LISP::DO COMMON-LISP::SYMBOL-MACROLET
+   COMMON-LISP::ABS COMMON-LISP::&KEY
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot READER|
+   COMMON-LISP::VECTOR-PUSH-EXTEND COMMON-LISP::DEFPACKAGE
+   COMMON-LISP::PACKAGE-NICKNAMES COMMON-LISP::MULTIPLE-VALUE-PROG1
+   COMMON-LISP::SYNONYM-STREAM-SYMBOL COMMON-LISP::RESTART-CASE
+   COMMON-LISP::END-OF-FILE COMMON-LISP::*DEFAULT-PATHNAME-DEFAULTS*
+   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot WRITER|
+   COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS COMMON-LISP::EXPT
+   COMMON-LISP::READER-ERROR COMMON-LISP::ABORT COMMON-LISP::CLASS-NAME
+   COMMON-LISP::REMHASH
+   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot WRITER|
+   COMMON-LISP::DOUBLE-FLOAT-EPSILON
+   COMMON-LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON COMMON-LISP::BOOLE-IOR
+   COMMON-LISP::ASSERT COMMON-LISP::ADJUSTABLE-ARRAY-P
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot BOUNDP|
+   COMMON-LISP::COPY-TREE COMMON-LISP::*PRINT-LINES* COMMON-LISP::DEBUG
+   COMMON-LISP::CLEAR-OUTPUT COMMON-LISP::CODE-CHAR
+   COMMON-LISP::STRING-CAPITALIZE COMMON-LISP::///
+   COMMON-LISP::WITH-OPEN-STREAM
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INDEX slot READER| COMMON-LISP::REST
+   COMMON-LISP::ACOS COMMON-LISP::MACHINE-TYPE
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INDEX slot WRITER| 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
+   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
+   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot WRITER|
+   COMMON-LISP::READ-SEQUENCE COMMON-LISP::FUNCTION-LAMBDA-EXPRESSION
+   COMMON-LISP::ARRAY-RANK-LIMIT COMMON-LISP::WRITE-SEQUENCE
+   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
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot WRITER| COMMON-LISP::LOGORC2
+   COMMON-LISP::*PACKAGE* COMMON-LISP::STRING-NOT-GREATERP
+   COMMON-LISP::INTERSECTION
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot READER|
+   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot READER|
+   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*
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot WRITER|
+   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
+   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 SLOT-ACCESSOR-NAME::|PCL LOCATION slot BOUNDP|
+   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
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL FIELD slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NAME slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot READER|
+   COMMON-LISP::FMAKUNBOUND COMMON-LISP::FUNCTION-KEYWORDS
+   SLOT-ACCESSOR-NAME::|PCL FIELD slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot READER|
+   COMMON-LISP::SUBST-IF COMMON-LISP::GET-DECODED-TIME
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot WRITER|
+   COMMON-LISP::LONG-FLOAT COMMON-LISP::SIMPLE-WARNING
+   COMMON-LISP::RATIO COMMON-LISP::EVENP COMMON-LISP::QUOTE
+   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot WRITER|
+   COMMON-LISP::PPRINT COMMON-LISP::SHORT-FLOAT-EPSILON
+   COMMON-LISP::SHORT-FLOAT-NEGATIVE-EPSILON COMMON-LISP::ACOSH
+   COMMON-LISP::LISTEN SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot WRITER|
+   COMMON-LISP::GENTEMP COMMON-LISP::ERROR COMMON-LISP::ADJUST-ARRAY
+   COMMON-LISP::ALLOCATE-INSTANCE
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot READER| COMMON-LISP::IF
+   COMMON-LISP::CAAAAR COMMON-LISP::SET-SYNTAX-FROM-CHAR
+   COMMON-LISP::STRING-TRIM COMMON-LISP::DIGIT-CHAR
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot READER|
+   COMMON-LISP::BOOLE-AND COMMON-LISP::*COMPILE-PRINT*
+   COMMON-LISP::STRING> COMMON-LISP::CAAAR COMMON-LISP::GETHASH
+   COMMON-LISP::METHOD-QUALIFIERS COMMON-LISP::FILL-POINTER
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot WRITER|
+   COMMON-LISP::METHOD-COMBINATION-ERROR COMMON-LISP::CDADDR
+   COMMON-LISP::REMOVE-METHOD COMMON-LISP::DIRECTORY-NAMESTRING
+   COMMON-LISP::DEFUN COMMON-LISP::TRUNCATE COMMON-LISP::ALPHA-CHAR-P
+   COMMON-LISP::SYMBOL-FUNCTION COMMON-LISP::SUBSTITUTE-IF-NOT
+   COMMON-LISP::LDB-TEST SLOT-ACCESSOR-NAME::|PCL INITFORM slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot READER|
+   COMMON-LISP::SXHASH COMMON-LISP::STREAM-EXTERNAL-FORMAT
+   COMMON-LISP::PACKAGE-USE-LIST COMMON-LISP::PACKAGE-USED-BY-LIST
+   COMMON-LISP::MACHINE-INSTANCE
+   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot READER| COMMON-LISP::ARRAYP
+   COMMON-LISP::*GENSYM-COUNTER* COMMON-LISP::UPPER-CASE-P
+   COMMON-LISP::*PRINT-CIRCLE*
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot WRITER|
+   COMMON-LISP::FTYPE COMMON-LISP::THE
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot WRITER|
+   COMMON-LISP::SET-PPRINT-DISPATCH COMMON-LISP::COPY-PPRINT-DISPATCH
+   COMMON-LISP::WRITE-TO-STRING COMMON-LISP::ARRAY-TOTAL-SIZE-LIMIT
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot WRITER|
+   COMMON-LISP::SEQUENCE COMMON-LISP::FILE-AUTHOR
+   COMMON-LISP::MULTIPLE-VALUE-CALL COMMON-LISP::*MACROEXPAND-HOOK*
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot WRITER| 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 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
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot READER|
+   COMMON-LISP::DEFMETHOD COMMON-LISP::BROADCAST-STREAM-STREAMS
+   COMMON-LISP::APPEND COMMON-LISP::CONCATENATE
+   COMMON-LISP::WRITE-STRING COMMON-LISP::MISMATCH
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot BOUNDP|
+   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 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
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot READER|
+   COMMON-LISP::LOGANDC1 COMMON-LISP::WITH-PACKAGE-ITERATOR
+   COMMON-LISP::SLOT-BOUNDP
+   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot READER| COMMON-LISP::NUMBERP
+   COMMON-LISP::COMPLEX
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot WRITER|
+   COMMON-LISP::INVOKE-RESTART-INTERACTIVELY COMMON-LISP::IGNORE-ERRORS
+   COMMON-LISP::AND COMMON-LISP::EVAL-WHEN COMMON-LISP::LOOP
+   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot WRITER|
+   COMMON-LISP::READ-FROM-STRING COMMON-LISP::*STANDARD-OUTPUT*
+   COMMON-LISP::CHAR-NAME COMMON-LISP::COMPILE-FILE COMMON-LISP::FLOAT
+   COMMON-LISP::*ERROR-OUTPUT* COMMON-LISP::TYPE-ERROR
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot READER|
+   COMMON-LISP::WITH-SLOTS
+   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot READER|
+   COMMON-LISP::ARRAY-ELEMENT-TYPE COMMON-LISP::FDEFINITION
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot WRITER|
+   COMMON-LISP::ROUND
+   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot WRITER|
+   COMMON-LISP::DECODE-FLOAT COMMON-LISP::PATHNAME-NAME
+   COMMON-LISP::STRING= COMMON-LISP::PHASE
+   COMMON-LISP::DEFINE-METHOD-COMBINATION 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
+   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
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot BOUNDP|
+   COMMON-LISP::VECTOR COMMON-LISP::INVOKE-RESTART
+   COMMON-LISP::UNSIGNED-BYTE COMMON-LISP::SERIOUS-CONDITION
+   COMMON-LISP::SYMBOL-PLIST
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot WRITER|
+   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 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
+   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot READER| COMMON-LISP::WHEN
+   COMMON-LISP::COMPILE COMMON-LISP::HASH-TABLE-REHASH-SIZE
+   COMMON-LISP::FLET COMMON-LISP::SPECIAL COMMON-LISP::CLASS
+   COMMON-LISP::CELL-ERROR COMMON-LISP::RPLACD COMMON-LISP::TYPE-OF
+   COMMON-LISP::SPECIAL-OPERATOR-P COMMON-LISP::PATHNAME-MATCH-P
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot WRITER|
+   COMMON-LISP::DESCRIBE COMMON-LISP::POSITION COMMON-LISP::STABLE-SORT
+   COMMON-LISP::BOTH-CASE-P
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot BOUNDP|
+   COMMON-LISP::SYMBOLP COMMON-LISP::*PRINT-READABLY*
+   COMMON-LISP::SHADOW COMMON-LISP::STREAM COMMON-LISP::MAKE-ARRAY
+   COMMON-LISP::FUNCTIONP
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot READER| COMMON-LISP::&WHOLE
+   COMMON-LISP::SUBST COMMON-LISP::SCHAR COMMON-LISP::ARRAY-DIMENSION
+   COMMON-LISP::COND COMMON-LISP::DO-EXTERNAL-SYMBOLS
+   COMMON-LISP::CHAR-CODE-LIMIT COMMON-LISP::SATISFIES
+   COMMON-LISP::MASK-FIELD COMMON-LISP::ARITHMETIC-ERROR
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot WRITER| 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
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot BOUNDP| 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::<= SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot READER|
+   COMMON-LISP::NAMESTRING COMMON-LISP::MAKE-CONCATENATED-STREAM
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot BOUNDP|
+   COMMON-LISP::MAKE-INSTANCE
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot READER|
+   COMMON-LISP::SHORT-FLOAT COMMON-LISP::FILE-STREAM
+   COMMON-LISP::WRITE-LINE COMMON-LISP::VECTOR-PUSH COMMON-LISP::ENDP
+   COMMON-LISP::DIRECTORY COMMON-LISP::TYPE COMMON-LISP::ASSOC-IF
+   COMMON-LISP::DPB SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot WRITER|
+   COMMON-LISP::TYPEP COMMON-LISP::FIFTH COMMON-LISP::LOGNAND
+   COMMON-LISP::SIGNED-BYTE COMMON-LISP::EVERY
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot BOUNDP|
+   COMMON-LISP::PPRINT-POP COMMON-LISP::SUBLIS COMMON-LISP::NULL
+   COMMON-LISP::FLOATP COMMON-LISP::STRING< COMMON-LISP::*TRACE-OUTPUT*
+   COMMON-LISP::WRITE-CHAR COMMON-LISP::*DEBUGGER-HOOK*
+   COMMON-LISP::*PRINT-RIGHT-MARGIN*
+   COMMON-LISP::STANDARD-GENERIC-FUNCTION COMMON-LISP::MAPL
+   SLOT-ACCESSOR-NAME::|PCL NLINES slot READER| 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
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL NLINES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER FORM slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|COMPILER FORM slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot WRITER|
+   COMMON-LISP::CHAR-INT COMMON-LISP::TAN
+   COMMON-LISP::MOST-NEGATIVE-FIXNUM COMMON-LISP::MAKE-SYNONYM-STREAM
+   COMMON-LISP::MACROEXPAND COMMON-LISP::CADDAR COMMON-LISP::ISQRT
+   COMMON-LISP::CCASE COMMON-LISP::COMPUTE-APPLICABLE-METHODS
+   SLOT-ACCESSOR-NAME::|PCL SIZE slot READER| COMMON-LISP::GCD
+   COMMON-LISP::KEYWORD SLOT-ACCESSOR-NAME::|PCL SIZE slot WRITER|
+   COMMON-LISP::UNLESS COMMON-LISP::MAP-INTO
+   COMMON-LISP::*LOAD-TRUENAME* COMMON-LISP::SIMPLE-ERROR
+   COMMON-LISP::SYNONYM-STREAM COMMON-LISP::SUBSETP
+   COMMON-LISP::POSITION-IF COMMON-LISP::INCF
+   SLOT-ACCESSOR-NAME::|PCL NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot BOUNDP|
+   COMMON-LISP::SHIFTF COMMON-LISP::BOOLE-XOR
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NKEYS slot READER| COMMON-LISP::REM
+   COMMON-LISP::LOGNOR
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL VALUEP slot READER| COMMON-LISP::FIND
+   COMMON-LISP::MAX COMMON-LISP::GET-SETF-EXPANSION
+   COMMON-LISP::PPRINT-DISPATCH
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot WRITER| 
+   SLOT-ACCESSOR-NAME::|PCL NKEYS slot WRITER|
+   COMMON-LISP::SIMPLE-VECTOR-P COMMON-LISP::SLOT-EXISTS-P
+   SLOT-ACCESSOR-NAME::|PCL VALUEP slot WRITER| 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
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot READER|
+   COMMON-LISP::WITH-OUTPUT-TO-STRING COMMON-LISP::BYTE-POSITION
+   COMMON-LISP::STANDARD-CHAR COMMON-LISP::STRING
+   COMMON-LISP::MEMBER-IF COMMON-LISP::NSTRING-UPCASE
+   COMMON-LISP::DEFMACRO
+   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot WRITER|
+   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
+   COMMON-LISP::DELETE
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot BOUNDP|
+   COMMON-LISP::FIND-RESTART COMMON-LISP::UNBOUND-SLOT
+   COMMON-LISP::RENAME-PACKAGE
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot WRITER|
+   COMMON-LISP::SIGNUM COMMON-LISP::CDDDDR 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::+++ COMMON-LISP::LCM
+   COMMON-LISP::BOOLE-NAND COMMON-LISP::SIMPLE-ARRAY
+   COMMON-LISP::CADDDR SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL KEY slot READER|
+   COMMON-LISP::SIMPLE-BIT-VECTOR COMMON-LISP::PRIN1
+   COMMON-LISP::BIT-ORC1 COMMON-LISP::*LOAD-PATHNAME*
+   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
+   SLOT-ACCESSOR-NAME::|PCL KEY slot WRITER| 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
+   COMMON-LISP::DIGIT-CHAR-P
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot READER|
+   COMMON-LISP::*STANDARD-INPUT* COMMON-LISP::BOUNDP COMMON-LISP::ODDP
+   COMMON-LISP::READ-DELIMITED-LIST
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot BOUNDP|
+   COMMON-LISP::ARITHMETIC-ERROR-OPERANDS COMMON-LISP::SIXTH
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot WRITER|
+   COMMON-LISP::SUBTYPEP COMMON-LISP::NSTRING-CAPITALIZE
+   COMMON-LISP::DECLARE COMMON-LISP::FLOOR
+   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot READER| COMMON-LISP::GENSYM
+   COMMON-LISP::ARRAY-HAS-FILL-POINTER-P COMMON-LISP::LOGIOR
+   COMMON-LISP::Y-OR-N-P COMMON-LISP::PARSE-NAMESTRING
+   COMMON-LISP::ARRAY-RANK
+   SLOT-ACCESSOR-NAME::|PCL READERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot WRITER| COMMON-LISP::NINTH
+   COMMON-LISP::WITH-INPUT-FROM-STRING COMMON-LISP::INTEGER
+   COMMON-LISP::MAKE-SEQUENCE
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot BOUNDP|
+   COMMON-LISP::SET-EXCLUSIVE-OR COMMON-LISP::CHAR< COMMON-LISP::INLINE
+   COMMON-LISP::CDDADR COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::TANH
+   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot READER| COMMON-LISP::ATAN
+   COMMON-LISP::NOT COMMON-LISP::LONG-SITE-NAME
+   COMMON-LISP::PATHNAME-VERSION COMMON-LISP::MAPCAN
+   COMMON-LISP::REQUIRE
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot READER| COMMON-LISP::RPLACA
+   COMMON-LISP::TAGBODY COMMON-LISP::COPY-ALIST COMMON-LISP::CADADR
+   COMMON-LISP::MAPCAR COMMON-LISP::RESTART-NAME COMMON-LISP::>
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot WRITER|
+   COMMON-LISP::FIND-PACKAGE COMMON-LISP::FBOUNDP
+   COMMON-LISP::DEFINE-SYMBOL-MACRO COMMON-LISP::=
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot WRITER| 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::< SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot READER|
+   COMMON-LISP::LOGCOUNT COMMON-LISP::ENOUGH-NAMESTRING
+   COMMON-LISP::MULTIPLE-VALUE-LIST
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot BOUNDP|
+   COMMON-LISP::TWO-WAY-STREAM COMMON-LISP::CDDR COMMON-LISP::ASSOC
+   COMMON-LISP::REMF COMMON-LISP::LDB COMMON-LISP::MACROLET
+   COMMON-LISP::CDADR
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot WRITER|
+   COMMON-LISP::UNION COMMON-LISP::FIND-ALL-SYMBOLS
+   COMMON-LISP::MAKE-PACKAGE COMMON-LISP::&OPTIONAL
+   COMMON-LISP::COPY-STRUCTURE COMMON-LISP::THIRD COMMON-LISP::LABELS
+   COMMON-LISP::BOOLE-C1 COMMON-LISP::PPRINT-INDENT
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot READER|
+   COMMON-LISP::FIND-IF-NOT COMMON-LISP::FORMATTER
+   COMMON-LISP::HANDLER-CASE COMMON-LISP::LOAD
+   COMMON-LISP::DELETE-IF-NOT COMMON-LISP::ACONS
+   COMMON-LISP::UNDEFINED-FUNCTION COMMON-LISP::WILD-PATHNAME-P
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot WRITER| COMMON-LISP::PACKAGEP
+   COMMON-LISP::ENCODE-UNIVERSAL-TIME COMMON-LISP::FORMAT
+   COMMON-LISP::TENTH COMMON-LISP::STRUCTURE-CLASS
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot READER|
+   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
+   COMMON-LISP::BOOLE-1 COMMON-LISP::REDUCE
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot WRITER|
+   COMMON-LISP::SVREF COMMON-LISP::TRANSLATE-PATHNAME
+   COMMON-LISP::NTH-VALUE COMMON-LISP::FORCE-OUTPUT
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot READER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot WRITER|
+   COMMON-LISP::SOFTWARE-VERSION COMMON-LISP::APROPOS-LIST
+   COMMON-LISP::POSITION-IF-NOT COMMON-LISP::READ-BYTE
+   COMMON-LISP::FLOAT-RADIX COMMON-LISP::DECF COMMON-LISP::PROG
+   COMMON-LISP::CALL-NEXT-METHOD COMMON-LISP::-
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot BOUNDP| COMMON-LISP::MAPCON
+   COMMON-LISP::CELL-ERROR-NAME 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::+ COMMON-LISP::PATHNAME-DEVICE
+   COMMON-LISP::MACRO-FUNCTION COMMON-LISP::MAPLIST
+   COMMON-LISP::REVERSE COMMON-LISP::FIND-SYMBOL COMMON-LISP::*
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHE slot READER| COMMON-LISP::LOCALLY
+   COMMON-LISP::BIT-ANDC2 COMMON-LISP::*FEATURES*
+   COMMON-LISP::DIVISION-BY-ZERO COMMON-LISP::ARRAY
+   COMMON-LISP::DEFPARAMETER COMMON-LISP::PATHNAME-DIRECTORY
+   COMMON-LISP::WITH-CONDITION-RESTARTS
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHE slot WRITER|
+   COMMON-LISP::STRING-NOT-LESSP COMMON-LISP::ELT COMMON-LISP::NTH
+   COMMON-LISP::RETURN-FROM COMMON-LISP::COMPILER-MACRO
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot BOUNDP| COMMON-LISP::BIGNUM
+   COMMON-LISP::PACKAGE-ERROR-PACKAGE COMMON-LISP::MAKE-SYMBOL
+   COMMON-LISP::WITH-COMPILATION-UNIT COMMON-LISP::FILL
+   COMMON-LISP::CHAR-CODE
+   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL PORT slot READER| COMMON-LISP::RESTART
+   COMMON-LISP::VECTOR-POP COMMON-LISP::MEMBER COMMON-LISP::REMOVE
+   SLOT-ACCESSOR-NAME::|PCL PORT slot WRITER| COMMON-LISP::PPRINT-TAB
+   COMMON-LISP::CHAR<= COMMON-LISP::PUSH
+   SLOT-ACCESSOR-NAME::|PCL NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot READER|
+   COMMON-LISP::PROGRAM-ERROR
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot READER|
+   COMMON-LISP::CHAR-UPCASE COMMON-LISP::*PRINT-PRETTY*
+   COMMON-LISP::MOST-POSITIVE-FIXNUM COMMON-LISP::PATHNAME-HOST
+   SLOT-ACCESSOR-NAME::|PCL NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot WRITER|
+   COMMON-LISP::DOCUMENTATION COMMON-LISP:://
+   COMMON-LISP::SHARED-INITIALIZE
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot READER| 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
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot WRITER|
+   COMMON-LISP::COMPILER-MACRO-FUNCTION COMMON-LISP::ROOM
+   COMMON-LISP::UNBOUND-SLOT-INSTANCE
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot WRITER| COMMON-LISP::COS
+   COMMON-LISP::CHAR-DOWNCASE
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot WRITER|
+   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 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
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot READER|
+   COMMON-LISP::PPRINT-LOGICAL-BLOCK COMMON-LISP::FIND-CLASS
+   COMMON-LISP::FOURTH COMMON-LISP::STRING<= COMMON-LISP::STRING>=
+   COMMON-LISP::STRING/= COMMON-LISP::SLEEP
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot READER|
+   COMMON-LISP::*PRINT-MISER-WIDTH* COMMON-LISP::BUILT-IN-CLASS
+   COMMON-LISP::*RANDOM-STATE*
+   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot READER|
+   COMMON-LISP::*COMPILE-FILE-PATHNAME*
+   COMMON-LISP::*COMPILE-FILE-TRUENAME*
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot WRITER|
+   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
+   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot WRITER|
+   COMMON-LISP::*READ-SUPPRESS* COMMON-LISP::PPRINT-FILL
+   COMMON-LISP::DOLIST COMMON-LISP::SIMPLE-BASE-STRING
+   COMMON-LISP::SLOT-VALUE
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot BOUNDP|
+   COMMON-LISP::LET COMMON-LISP::CHAR-NOT-GREATERP
+   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot READER|
+   COMMON-LISP::PATHNAMEP COMMON-LISP::READ COMMON-LISP::RANDOM-STATE-P
+   COMMON-LISP::*READ-EVAL*
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot READER| COMMON-LISP::CDDAR
+   COMMON-LISP::REMOVE-IF COMMON-LISP::&ALLOW-OTHER-KEYS
+   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot WRITER| COMMON-LISP::FROUND
+   COMMON-LISP::CHAR-EQUAL COMMON-LISP::MAKE-DISPATCH-MACRO-CHARACTER
+   COMMON-LISP::EIGHTH COMMON-LISP::OPTIMIZE
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot WRITER| 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
+   SLOT-ACCESSOR-NAME::|PCL READERS slot READER| COMMON-LISP::REALP
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL MASK slot READER| COMMON-LISP::FCEILING
+   COMMON-LISP::COPY-SYMBOL
+   SLOT-ACCESSOR-NAME::|PCL READERS slot WRITER|
+   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS COMMON-LISP::CHAR
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL MASK slot WRITER|
+   COMMON-LISP::STANDARD-CHAR-P COMMON-LISP::*DEBUG-IO*
+   COMMON-LISP::FIXNUM COMMON-LISP::COMPILED-FUNCTION-P
+   COMMON-LISP::COUNT-IF COMMON-LISP::**
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OWNER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot READER|
+   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)
+ "SLOT-ACCESSOR-NAME")
+
+;;; Definitions for package ITERATE of type SHADOW
+(COMMON-LISP::SHADOW 'COMMON-LISP::NIL "ITERATE")
+(COMMON-LISP::SHADOWING-IMPORT 'COMMON-LISP::NIL "ITERATE")
+(COMMON-LISP::IMPORT
+ '(ITERATE::SUMMING
+   ITERATE::MINIMIZING ITERATE::PLIST-ELEMENTS ITERATE::ITERATE*
+   ITERATE::MAXIMIZING ITERATE::LIST-TAILS ITERATE::*ITERATE-WARNINGS*
+   ITERATE::GATHERING ITERATE::EACHTIME ITERATE::ELEMENTS
+   ITERATE::GATHER ITERATE::LIST-ELEMENTS ITERATE::WHILE
+   ITERATE::ITERATE ITERATE::UNTIL ITERATE::JOINING ITERATE::COLLECTING
+   ITERATE::WITH-GATHERING ITERATE::INTERVAL COMMON-LISP::EXP
+   COMMON-LISP::DEFVAR COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
+   COMMON-LISP::DISASSEMBLE COMMON-LISP::DELETE-IF
+   COMMON-LISP::CONCATENATED-STREAM-STREAMS COMMON-LISP::CLASS-OF
+   COMMON-LISP::NSUBST-IF-NOT COMMON-LISP::CIS COMMON-LISP::LOGAND
+   COMMON-LISP::BIT-EQV COMMON-LISP::MAKE-INSTANCES-OBSOLETE
+   ITERATE::MAYBE-WARN ITERATE::PLIST COMMON-LISP::RANDOM
+   COMMON-LISP::COPY-LIST WALKER::VARIABLE-DECLARATION
+   COMMON-LISP::KEYWORDP 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
+   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
+   ITERATE::MV-SETQ ITERATE::FINISH-ARG COMMON-LISP::COSH
+   COMMON-LISP::NTHCDR COMMON-LISP::GET-UNIVERSAL-TIME
+   COMMON-LISP::YES-OR-NO-P ITERATE::FUNCTION-LAMBDA-P ITERATE::ACC-VAR
+   COMMON-LISP::READ-LINE COMMON-LISP::LET* COMMON-LISP::PATHNAME-TYPE
+   ITERATE::RENAME-LET-BINDINGS ITERATE::BOUND-VAR-LISTS
+   COMMON-LISP::FLOAT-PRECISION COMMON-LISP::PROG*
+   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 COMMON-LISP::UNWIND-PROTECT
+   COMMON-LISP::CONSP ITERATE::GS COMMON-LISP::FLOAT-SIGN
+   COMMON-LISP::SOME COMMON-LISP::MAPC ITERATE::BODY COMMON-LISP::SETF
+   COMMON-LISP::CEILING COMMON-LISP::&BODY COMMON-LISP::CDAR
+   COMMON-LISP::STANDARD COMMON-LISP::MAKE-LIST ITERATE::ALIST
+   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 ITERATE::WARN-ARGS
+   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 ITERATE::ITERATE-TEMP-5
+   ITERATE::TO COMMON-LISP::SAFETY
+   COMMON-LISP::*READ-DEFAULT-FLOAT-FORMAT* COMMON-LISP::*LOAD-VERBOSE*
+   COMMON-LISP::OTHERWISE COMMON-LISP::NBUTLAST ITERATE::CLAUSES
+   COMMON-LISP::ADD-METHOD COMMON-LISP::PPRINT-EXIT-IF-LIST-EXHAUSTED
+   COMMON-LISP::SORT COMMON-LISP::WARNING ITERATE::PARENT-NAME
+   COMMON-LISP::DEFINE-COMPILER-MACRO COMMON-LISP::PROGN
+   COMMON-LISP::PUSHNEW COMMON-LISP::CHAR=
+   COMMON-LISP::MAKE-ECHO-STREAM COMMON-LISP::BIT-AND
+   COMMON-LISP::EXPORT 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 ITERATE::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 ITERATE::CLAUSE ITERATE::EXPANDEDP
+   COMMON-LISP::BIT-VECTOR COMMON-LISP::SEARCH
+   COMMON-LISP::STREAM-ELEMENT-TYPE COMMON-LISP::POP
+   COMMON-LISP::SLOT-UNBOUND COMMON-LISP::GO COMMON-LISP::LIST
+   COMMON-LISP::*LOAD-PRINT* ITERATE::OPTIMIZE-GATHERING-FORM
+   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
+   WALKER::*VARIABLE-DECLARATIONS* ITERATE::CLOSED COMMON-LISP::CHAR/=
+   ITERATE::VAR-LIST COMMON-LISP::REMPROP COMMON-LISP::DO
+   COMMON-LISP::SYMBOL-MACROLET ITERATE::BINDING-TYPE COMMON-LISP::ABS
+   COMMON-LISP::&KEY COMMON-LISP::VECTOR-PUSH-EXTEND
+   COMMON-LISP::DEFPACKAGE COMMON-LISP::PACKAGE-NICKNAMES
+   COMMON-LISP::MULTIPLE-VALUE-PROG1 ITERATE::EXPR ITERATE::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
+   COMMON-LISP::READER-ERROR COMMON-LISP::ABORT COMMON-LISP::CLASS-NAME
+   COMMON-LISP::REMHASH ITERATE::TEMP-VARS ITERATE::EXTRA-BODY
+   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
+   COMMON-LISP::DOUBLE-FLOAT-EPSILON
+   COMMON-LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON COMMON-LISP::BOOLE-IOR
+   COMMON-LISP::ASSERT COMMON-LISP::ADJUSTABLE-ARRAY-P
+   ITERATE::ITERATE-TEMP-3 COMMON-LISP::COPY-TREE
+   COMMON-LISP::*PRINT-LINES* COMMON-LISP::DEBUG ITERATE::VAR
+   COMMON-LISP::CLEAR-OUTPUT COMMON-LISP::CODE-CHAR
+   COMMON-LISP::STRING-CAPITALIZE COMMON-LISP::///
+   COMMON-LISP::WITH-OPEN-STREAM COMMON-LISP::REST ITERATE::ENV1
+   COMMON-LISP::ACOS COMMON-LISP::MACHINE-TYPE ITERATE::OTHER
+   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
+   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 ITERATE::REALIZER-NAMES
+   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
+   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 ITERATE::%ORPHANED-GATHER
+   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 COMMON-LISP::LOGORC2 COMMON-LISP::*PACKAGE*
+   COMMON-LISP::STRING-NOT-GREATERP COMMON-LISP::INTERSECTION
+   ITERATE::TAIL ITERATE::LOCALS 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
+   ITERATE::GATHERING-ENV 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
+   ITERATE::ACC-INFO COMMON-LISP::HANDLER-BIND COMMON-LISP::PAIRLIS
+   ITERATE::RENAMED-VARS COMMON-LISP::*PRINT-GENSYM*
+   COMMON-LISP::COMPILE-FILE-PATHNAME COMMON-LISP::CAR
+   COMMON-LISP::FTRUNCATE ITERATE::GET-ITERATE-TEMP
+   COMMON-LISP::DELETE-DUPLICATES COMMON-LISP::NREVERSE
+   COMMON-LISP::APROPOS ITERATE::HANDLE-LET ITERATE::PAIR
+   COMMON-LISP::STRING-RIGHT-TRIM ITERATE::SUBENV
+   COMMON-LISP::NO-NEXT-METHOD COMMON-LISP::STEP COMMON-LISP::BIT-NOR
+   COMMON-LISP::ARRAY-TOTAL-SIZE COMMON-LISP::ECHO-STREAM
+   WALKER::DEFINE-WALKER-TEMPLATE ITERATE::SEQUENCE-ACCESSOR
+   ITERATE::ITERATE-TEMP-1 COMMON-LISP::FMAKUNBOUND
+   COMMON-LISP::FUNCTION-KEYWORDS COMMON-LISP::SUBST-IF
+   COMMON-LISP::GET-DECODED-TIME ITERATE::*ANONYMOUS-GATHERING-SITE*
+   COMMON-LISP::LONG-FLOAT COMMON-LISP::SIMPLE-WARNING
+   COMMON-LISP::RATIO COMMON-LISP::EVENP COMMON-LISP::QUOTE
+   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 ITERATE::SUM 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
+   ITERATE::RNAME 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
+   ITERATE::VALUEFORM 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 ITERATE::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
+   COMMON-LISP::SXHASH COMMON-LISP::STREAM-EXTERNAL-FORMAT
+   COMMON-LISP::PACKAGE-USE-LIST COMMON-LISP::PACKAGE-USED-BY-LIST
+   COMMON-LISP::MACHINE-INSTANCE COMMON-LISP::ARRAYP
+   COMMON-LISP::*GENSYM-COUNTER* COMMON-LISP::UPPER-CASE-P
+   COMMON-LISP::*PRINT-CIRCLE* COMMON-LISP::FTYPE COMMON-LISP::THE
+   COMMON-LISP::SET-PPRINT-DISPATCH COMMON-LISP::COPY-PPRINT-DISPATCH
+   COMMON-LISP::WRITE-TO-STRING COMMON-LISP::ARRAY-TOTAL-SIZE-LIMIT
+   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
+   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 COMMON-LISP::DEFMETHOD
+   COMMON-LISP::BROADCAST-STREAM-STREAMS ITERATE::NEWVAR
+   COMMON-LISP::APPEND COMMON-LISP::CONCATENATE
+   COMMON-LISP::WRITE-STRING COMMON-LISP::MISMATCH ITERATE::BINDINGS
+   ITERATE::PUNT 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 COMMON-LISP::CLRHASH
+   COMMON-LISP::SHORT-SITE-NAME COMMON-LISP::LOAD-TIME-VALUE
+   COMMON-LISP::LONG-FLOAT-EPSILON
+   COMMON-LISP::LONG-FLOAT-NEGATIVE-EPSILON
+   ITERATE::ITERATE-TRANSFORM-BODY ITERATE::*ACTIVE-GATHERERS*
+   ITERATE::INITIAL-VALUE COMMON-LISP::ASSOC-IF-NOT
+   COMMON-LISP::MAKE-METHOD COMMON-LISP::CAAADR
+   COMMON-LISP::SLOT-MAKUNBOUND ITERATE::GENERATOR
+   COMMON-LISP::LOGANDC1 COMMON-LISP::WITH-PACKAGE-ITERATOR
+   COMMON-LISP::SLOT-BOUNDP ITERATE::FINISHDECL COMMON-LISP::NUMBERP
+   COMMON-LISP::COMPLEX 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* 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
+   ITERATE::RENAMING COMMON-LISP::ARRAY-ELEMENT-TYPE
+   COMMON-LISP::FDEFINITION ITERATE::ITERATE-TEMP-8 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= ITERATE::NAMES COMMON-LISP::PHASE
+   COMMON-LISP::DEFINE-METHOD-COMBINATION 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
+   ITERATE::PARSE-DECLARATIONS ITERATE::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>
+   ITERATE::FINISH-FORM 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
+   ITERATE::VALUE ITERATE::ACCUMULATOR COMMON-LISP::SERIOUS-CONDITION
+   COMMON-LISP::SYMBOL-PLIST ITERATE::INC 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 ITERATE::SITE 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
+   ITERATE::GENERATOR-DECLS 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 COMMON-LISP::WHEN COMMON-LISP::COMPILE
+   COMMON-LISP::HASH-TABLE-REHASH-SIZE COMMON-LISP::FLET
+   COMMON-LISP::SPECIAL COMMON-LISP::CLASS COMMON-LISP::CELL-ERROR
+   COMMON-LISP::RPLACD COMMON-LISP::TYPE-OF
+   COMMON-LISP::SPECIAL-OPERATOR-P COMMON-LISP::PATHNAME-MATCH-P
+   COMMON-LISP::DESCRIBE COMMON-LISP::POSITION COMMON-LISP::STABLE-SORT
+   COMMON-LISP::BOTH-CASE-P COMMON-LISP::SYMBOLP
+   COMMON-LISP::*PRINT-READABLY* ITERATE::WHOLE COMMON-LISP::SHADOW
+   COMMON-LISP::STREAM COMMON-LISP::MAKE-ARRAY COMMON-LISP::FUNCTIONP
+   ITERATE::CONTEXT COMMON-LISP::&WHOLE COMMON-LISP::SUBST
+   COMMON-LISP::SCHAR COMMON-LISP::ARRAY-DIMENSION COMMON-LISP::COND
+   COMMON-LISP::DO-EXTERNAL-SYMBOLS COMMON-LISP::CHAR-CODE-LIMIT
+   COMMON-LISP::SATISFIES COMMON-LISP::MASK-FIELD
+   COMMON-LISP::ARITHMETIC-ERROR COMMON-LISP::CADDR
+   COMMON-LISP::LAMBDA-LIST-KEYWORDS COMMON-LISP::STRING-NOT-EQUAL
+   COMMON-LISP::CONTINUE COMMON-LISP::STRING-LESSP SYSTEM::MACRO
+   COMMON-LISP::USE-PACKAGE COMMON-LISP::MULTIPLE-VALUE-SETQ
+   ITERATE::EXTRACT-SPECIAL-BINDINGS COMMON-LISP::>=
+   COMMON-LISP::LOGEQV COMMON-LISP::HASH-TABLE-P
+   COMMON-LISP::GRAPHIC-CHAR-P ITERATE::ITERATE-TEMP-6
+   COMMON-LISP::PRINT-UNREADABLE-OBJECT COMMON-LISP::EQL
+   COMMON-LISP::MAPHASH ITERATE::TEMPVARFN COMMON-LISP::NINTERSECTION
+   COMMON-LISP::<= 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
+   COMMON-LISP::DIRECTORY COMMON-LISP::TYPE COMMON-LISP::ASSOC-IF
+   COMMON-LISP::DPB ITERATE::VARIABLE-SAME-P COMMON-LISP::TYPEP
+   COMMON-LISP::FIFTH COMMON-LISP::LOGNAND COMMON-LISP::SIGNED-BYTE
+   COMMON-LISP::EVERY COMMON-LISP::PPRINT-POP COMMON-LISP::SUBLIS
+   COMMON-LISP::NULL COMMON-LISP::FLOATP COMMON-LISP::STRING<
+   COMMON-LISP::*TRACE-OUTPUT* ITERATE::RESULT 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 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
+   ITERATE::ENV COMMON-LISP::MACROEXPAND COMMON-LISP::CADDAR
+   COMMON-LISP::ISQRT COMMON-LISP::CCASE
+   COMMON-LISP::COMPUTE-APPLICABLE-METHODS ITERATE::DOWNFROM
+   ITERATE::FINISH COMMON-LISP::GCD WALKER::NESTED-WALK-FORM
+   WALKER::WALK-FORM-EXPAND-MACROS-P ITERATE::WALK-GATHERING-BODY
+   COMMON-LISP::KEYWORD ITERATE::BOUND-VARS ITERATE::OTHERDECLS
+   ITERATE::FINISH-FORMS COMMON-LISP::UNLESS COMMON-LISP::MAP-INTO
+   COMMON-LISP::*LOAD-TRUENAME* COMMON-LISP::SIMPLE-ERROR
+   COMMON-LISP::SYNONYM-STREAM COMMON-LISP::SUBSETP
+   COMMON-LISP::POSITION-IF COMMON-LISP::INCF ITERATE::TOP-BINDINGS
+   COMMON-LISP::SHIFTF COMMON-LISP::BOOLE-XOR COMMON-LISP::REM
+   COMMON-LISP::LOGNOR ITERATE::FORM 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
+   ITERATE::ITERATE-TEMP-4 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 ITERATE::DOWN
+   COMMON-LISP::WITH-OUTPUT-TO-STRING COMMON-LISP::BYTE-POSITION
+   COMMON-LISP::STANDARD-CHAR COMMON-LISP::STRING
+   COMMON-LISP::MEMBER-IF ITERATE::X COMMON-LISP::NSTRING-UPCASE
+   COMMON-LISP::DEFMACRO COMMON-LISP::BUTLAST
+   COMMON-LISP::NEXT-METHOD-P COMMON-LISP::CDDAAR
+   COMMON-LISP::RESTART-BIND ITERATE::V 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 ITERATE::S
+   ITERATE::USE-BODY COMMON-LISP::DELETE ITERATE::LIMIT
+   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 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::+++ ITERATE::GVAR
+   COMMON-LISP::LCM COMMON-LISP::BOOLE-NAND COMMON-LISP::SIMPLE-ARRAY
+   COMMON-LISP::CADDDR ITERATE::*ITERATE-TEMP-VARS-LIST* ITERATE::L
+   COMMON-LISP::SIMPLE-BIT-VECTOR COMMON-LISP::PRIN1
+   COMMON-LISP::BIT-ORC1 COMMON-LISP::*LOAD-PATHNAME*
+   WALKER::MACROEXPAND-ALL ITERATE::OPTIMIZE-ITERATE-FORM ITERATE::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 ITERATE::ENV2
+   ITERATE::ACC-NAMES COMMON-LISP::DEPOSIT-FIELD
+   COMMON-LISP::*QUERY-IO* COMMON-LISP::MAKE-CONDITION
+   ITERATE::GEN-ARGS 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 COMMON-LISP::DIGIT-CHAR-P
+   COMMON-LISP::*STANDARD-INPUT* COMMON-LISP::BOUNDP COMMON-LISP::ODDP
+   COMMON-LISP::READ-DELIMITED-LIST
+   COMMON-LISP::ARITHMETIC-ERROR-OPERANDS COMMON-LISP::SIXTH
+   COMMON-LISP::SUBTYPEP COMMON-LISP::NSTRING-CAPITALIZE
+   COMMON-LISP::DECLARE COMMON-LISP::FLOOR ITERATE::D
+   COMMON-LISP::GENSYM COMMON-LISP::ARRAY-HAS-FILL-POINTER-P
+   COMMON-LISP::LOGIOR 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
+   ITERATE::ITERATE-TEMP-2 COMMON-LISP::SET-EXCLUSIVE-OR
+   COMMON-LISP::CHAR< COMMON-LISP::INLINE COMMON-LISP::CDDADR
+   ITERATE::ABOVE 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 ITERATE::EXPAND-INTO-LET
+   ITERATE::VARIABLES-FROM-LET COMMON-LISP::RPLACA COMMON-LISP::TAGBODY
+   COMMON-LISP::COPY-ALIST COMMON-LISP::CADADR COMMON-LISP::MAPCAR
+   COMMON-LISP::RESTART-NAME COMMON-LISP::> ITERATE::UPDATE-FORMS
+   ITERATE::LOCALDECLS COMMON-LISP::FIND-PACKAGE COMMON-LISP::FBOUNDP
+   COMMON-LISP::DEFINE-SYMBOL-MACRO COMMON-LISP::= 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::< 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
+   COMMON-LISP::UNION COMMON-LISP::FIND-ALL-SYMBOLS
+   COMMON-LISP::MAKE-PACKAGE WALKER::VARIABLE-SPECIAL-P
+   COMMON-LISP::&OPTIONAL COMMON-LISP::COPY-STRUCTURE
+   COMMON-LISP::THIRD COMMON-LISP::LABELS COMMON-LISP::BOOLE-C1
+   COMMON-LISP::PPRINT-INDENT ITERATE::LEFTOVER-BODY
+   COMMON-LISP::FIND-IF-NOT COMMON-LISP::FORMATTER
+   COMMON-LISP::HANDLER-CASE 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
+   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
+   COMMON-LISP::BOOLE-1 COMMON-LISP::REDUCE COMMON-LISP::SVREF
+   COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::NTH-VALUE
+   COMMON-LISP::FORCE-OUTPUT WALKER::WALK-FORM
+   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 ITERATE::LET-BODY ITERATE::SPECIALS
+   COMMON-LISP::REPLACE COMMON-LISP::*** COMMON-LISP::GENERIC-FUNCTION
+   COMMON-LISP::/ COMMON-LISP::BOOLE-SET ITERATE::GATHER-BODY
+   COMMON-LISP::SOFTWARE-VERSION COMMON-LISP::APROPOS-LIST
+   COMMON-LISP::POSITION-IF-NOT COMMON-LISP::READ-BYTE
+   COMMON-LISP::FLOAT-RADIX COMMON-LISP::DECF COMMON-LISP::PROG
+   COMMON-LISP::CALL-NEXT-METHOD COMMON-LISP::-
+   WALKER::VARIABLE-LEXICAL-P COMMON-LISP::MAPCON
+   COMMON-LISP::CELL-ERROR-NAME ITERATE::ITERATE-DECLS
+   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::+ ITERATE::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 ITERATE::INFO 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 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 ITERATE::ACCESSOR
+   COMMON-LISP::RESTART COMMON-LISP::VECTOR-POP COMMON-LISP::MEMBER
+   ITERATE::VARS COMMON-LISP::REMOVE COMMON-LISP::PPRINT-TAB
+   COMMON-LISP::CHAR<= COMMON-LISP::PUSH COMMON-LISP::PROGRAM-ERROR
+   ITERATE::FROM ITERATE::TOP-DECLS 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 ITERATE::ITERATE-ENV
+   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
+   COMMON-LISP::COMPILER-MACRO-FUNCTION COMMON-LISP::ROOM
+   COMMON-LISP::UNBOUND-SLOT-INSTANCE ITERATE::SIZE COMMON-LISP::COS
+   COMMON-LISP::CHAR-DOWNCASE ITERATE::RENAME-VARIABLES
+   COMMON-LISP::CONSTANTLY COMMON-LISP::RATIONALIZE
+   COMMON-LISP::LISP-IMPLEMENTATION-VERSION ITERATE::LET-BINDINGS
+   COMMON-LISP::CONSTANTP COMMON-LISP::HASH-TABLE-COUNT
+   COMMON-LISP::STREAMP COMMON-LISP::NO-APPLICABLE-METHOD
+   ITERATE::SIMPLE-EXPAND-GATHERING-FORM
+   ITERATE::SIMPLE-EXPAND-ITERATE-FORM COMMON-LISP::1-
+   COMMON-LISP::BIT-XOR ITERATE::DOWNTO COMMON-LISP::STRING-STREAM
+   COMMON-LISP::GET-PROPERTIES COMMON-LISP::COUNT-IF-NOT
+   COMMON-LISP::BIT COMMON-LISP::ASH COMMON-LISP::NSUBLIS
+   ITERATE::EXPAND COMMON-LISP::PPRINT-LOGICAL-BLOCK
+   COMMON-LISP::FIND-CLASS COMMON-LISP::FOURTH ITERATE::DECLS
+   ITERATE::INDEX COMMON-LISP::STRING<= COMMON-LISP::STRING>=
+   COMMON-LISP::STRING/= COMMON-LISP::SLEEP 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 ITERATE::GENERATOR-VARS
+   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* 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 ITERATE::NARGS COMMON-LISP::PATHNAMEP
+   COMMON-LISP::READ COMMON-LISP::RANDOM-STATE-P
+   COMMON-LISP::*READ-EVAL* ITERATE::BY COMMON-LISP::CDDAR
+   COMMON-LISP::REMOVE-IF COMMON-LISP::&ALLOW-OTHER-KEYS
+   ITERATE::RENAME-AND-CAPTURE-VARIABLES COMMON-LISP::FROUND
+   COMMON-LISP::CHAR-EQUAL COMMON-LISP::MAKE-DISPATCH-MACRO-CHARACTER
+   COMMON-LISP::EIGHTH COMMON-LISP::OPTIMIZE COMMON-LISP::++
+   COMMON-LISP::DO* COMMON-LISP::SIMPLE-TYPE-ERROR COMMON-LISP::ASIN
+   COMMON-LISP::SINGLE-FLOAT WALKER::VARIABLE-GLOBALLY-SPECIAL-P
+   COMMON-LISP::REAL COMMON-LISP::CHARACTER COMMON-LISP::CHARACTERP
+   COMMON-LISP::GET COMMON-LISP::REALP ITERATE::GEN-VAR
+   COMMON-LISP::FCEILING COMMON-LISP::COPY-SYMBOL
+   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS COMMON-LISP::CHAR
+   ITERATE::ITERATE-TEMP-7 ITERATE::BELOW COMMON-LISP::STANDARD-CHAR-P
+   COMMON-LISP::*DEBUG-IO* COMMON-LISP::FIXNUM
+   COMMON-LISP::COMPILED-FUNCTION-P COMMON-LISP::COUNT-IF
+   COMMON-LISP::** ITERATE::HEAD ITERATE::REALIZER
+   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)
+ "ITERATE")
+
+;;; Definitions for package PCL of type SHADOW
+(COMMON-LISP::SHADOW 'COMMON-LISP::NIL "PCL")
+(COMMON-LISP::SHADOWING-IMPORT 'COMMON-LISP::NIL "PCL")
+(COMMON-LISP::IMPORT
+ '(PCL::CLASS-PRECEDENCE-LIST
+   PCL::SLOT-DEFINITION PCL::COMPUTE-APPLICABLE-METHODS-USING-CLASSES
+   PCL::SLOT-DEFINITION-WRITERS COMMON-LISP::CLASS-OF
+   COMMON-LISP::NO-APPLICABLE-METHOD PCL::STANDARD-WRITER-METHOD
+   PCL::ENSURE-CLASS-USING-CLASS COMMON-LISP::ENSURE-GENERIC-FUNCTION
+   PCL::FIND-METHOD-COMBINATION PCL::UPDATE-DEPENDENT
+   PCL::MAP-DEPENDENTS COMMON-LISP::SLOT-MISSING PCL::SPECIALIZER
+   COMMON-LISP::CALL-NEXT-METHOD
+   PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS
+   PCL::SLOT-MAKUNBOUND-USING-CLASS
+   COMMON-LISP::MAKE-INSTANCES-OBSOLETE PCL::INTERN-EQL-SPECIALIZER
+   PCL::REMOVE-DIRECT-SUBCLASS PCL::METHOD-GENERIC-FUNCTION
+   COMMON-LISP::METHOD-QUALIFIERS PCL::FUNCALLABLE-STANDARD-CLASS
+   PCL::EXTRACT-LAMBDA-LIST COMMON-LISP::STANDARD-CLASS
+   COMMON-LISP::PRINT-OBJECT COMMON-LISP::STRUCTURE-CLASS
+   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION
+   PCL::GENERIC-FUNCTION-DECLARATIONS COMMON-LISP::MAKE-INSTANCE
+   PCL::METHOD-LAMBDA-LIST COMMON-LISP::DEFGENERIC
+   PCL::REMOVE-DIRECT-METHOD PCL::STANDARD-DIRECT-SLOT-DEFINITION
+   PCL::GENERIC-FUNCTION-METHODS PCL::VALIDATE-SUPERCLASS
+   COMMON-LISP::REINITIALIZE-INSTANCE COMMON-LISP::STANDARD-METHOD
+   PCL::STANDARD-ACCESSOR-METHOD PCL::FUNCALLABLE-STANDARD-INSTANCE
+   COMMON-LISP::FUNCTION-KEYWORDS COMMON-LISP::STANDARD
+   COMMON-LISP::FIND-METHOD PCL::EXTRACT-SPECIALIZER-NAMES
+   COMMON-LISP::INITIALIZE-INSTANCE PCL::GENERIC-FLET
+   COMMON-LISP::SLOT-UNBOUND PCL::STANDARD-INSTANCE
+   PCL::SLOT-DEFINITION-TYPE PCL::COMPUTE-EFFECTIVE-METHOD
+   COMMON-LISP::ALLOCATE-INSTANCE COMMON-LISP::SYMBOL-MACROLET
+   COMMON-LISP::GENERIC-FUNCTION
+   PCL::GENERIC-FUNCTION-METHOD-COMBINATION
+   PCL::SPECIALIZER-DIRECT-METHODS PCL::ADD-DIRECT-SUBCLASS
+   PCL::WRITER-METHOD-CLASS PCL::SLOT-DEFINITION-INITARGS
+   PCL::METHOD-SPECIALIZERS PCL::GENERIC-FUNCTION-METHOD-CLASS
+   COMMON-LISP::ADD-METHOD COMMON-LISP::WITH-ACCESSORS
+   PCL::SLOT-DEFINITION-ALLOCATION PCL::SLOT-DEFINITION-INITFUNCTION
+   PCL::SLOT-DEFINITION-LOCATION PCL::ADD-DIRECT-METHOD
+   COMMON-LISP::SLOT-BOUNDP PCL::EQL-SPECIALIZER
+   COMMON-LISP::SHARED-INITIALIZE
+   COMMON-LISP::STANDARD-GENERIC-FUNCTION
+   PCL::ACCESSOR-METHOD-SLOT-DEFINITION PCL::SLOT-BOUNDP-USING-CLASS
+   PCL::ADD-DEPENDENT PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTION
+   PCL::WITH-ADDED-METHODS PCL::COMPUTE-CLASS-PRECEDENCE-LIST
+   COMMON-LISP::MAKE-LOAD-FORM-SAVING-SLOTS PCL::REMOVE-DEPENDENT
+   COMMON-LISP::NEXT-METHOD-P PCL::GENERIC-FUNCTION-NAME
+   COMMON-LISP::SLOT-VALUE PCL::EFFECTIVE-SLOT-DEFINITION
+   PCL::CLASS-FINALIZED-P PCL::COMPUTE-DISCRIMINATING-FUNCTION
+   COMMON-LISP::STANDARD-OBJECT PCL::CLASS-DEFAULT-INITARGS
+   PCL::CLASS-DIRECT-SLOTS PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS
+   COMMON-LISP::BUILT-IN-CLASS COMMON-LISP::NO-NEXT-METHOD
+   COMMON-LISP::SLOT-MAKUNBOUND PCL::STANDARD-READER-METHOD
+   PCL::GENERIC-FUNCTION-LAMBDA-LIST
+   PCL::GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
+   COMMON-LISP::INVALID-METHOD-ERROR
+   COMMON-LISP::METHOD-COMBINATION-ERROR COMMON-LISP::SLOT-EXISTS-P
+   PCL::FINALIZE-INHERITANCE PCL::SLOT-DEFINITION-NAME
+   PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION PCL::COMPUTE-SLOTS
+   PCL::CLASS-SLOTS PCL::EFFECTIVE-SLOT-DEFINITION-CLASS
+   PCL::STANDARD-INSTANCE-ACCESS COMMON-LISP::WITH-SLOTS
+   PCL::DIRECT-SLOT-DEFINITION COMMON-LISP::DEFINE-METHOD-COMBINATION
+   PCL::MAKE-METHOD-LAMBDA PCL::ENSURE-CLASS
+   PCL::DIRECT-SLOT-DEFINITION-CLASS COMMON-LISP::MAKE-LOAD-FORM
+   PCL::METHOD-FUNCTION PCL::STANDARD-SLOT-DEFINITION
+   COMMON-LISP::CHANGE-CLASS COMMON-LISP::DEFMETHOD
+   COMMON-LISP::UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
+   COMMON-LISP::UPDATE-INSTANCE-FOR-REDEFINED-CLASS
+   PCL::FORWARD-REFERENCED-CLASS PCL::SLOT-DEFINITION-INITFORM
+   COMMON-LISP::REMOVE-METHOD PCL::READER-METHOD-CLASS
+   COMMON-LISP::CALL-METHOD PCL::CLASS-PROTOTYPE
+   COMMON-LISP::CLASS-NAME COMMON-LISP::FIND-CLASS
+   COMMON-LISP::DEFCLASS COMMON-LISP::COMPUTE-APPLICABLE-METHODS
+   COMMON-LISP::DESCRIBE-OBJECT PCL::SLOT-VALUE-USING-CLASS
+   COMMON-LISP::METHOD-COMBINATION PCL::EQL-SPECIALIZER-INSTANCE
+   PCL::GENERIC-LABELS COMMON-LISP::METHOD PCL::SLOT-DEFINITION-READERS
+   PCL::CLASS-DIRECT-DEFAULT-INITARGS PCL::CLASS-DIRECT-SUBCLASSES
+   PCL::CLASS-DIRECT-SUPERCLASSES
+   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 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::FUNCALLABLE-STANDARD-CLASS-SIMPLE-TYPEP-FN
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFORM)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
+   PCL::%STD-INSTANCE- PCL::.QUALIFIERS. PCL::REMOVE-NAMED-METHOD
+   PCL::CACHE-FIELD PCL::INSTANCE-SLOTDS PCL::FSC
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT 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 COMPILER::RETURN-TYPE)|
+   PCL::GCL_PCL_SLOTS PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::INSTANCE
+   COMMON-LISP::SIMPLE-CONDITION
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION READERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION WRITERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NKEYS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
+   PCL::DEFINITIONS PCL::DFUN-INFO-WRAPPER0 PCL::REMTAIL
+   PCL::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::|(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-DEFINITION CLASS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS)| PCL::FIRST-P
+   PCL::DFUN-INFO-ACCESSOR-TYPE S::C-FLOAT-DOUBLE->
+   PCL::SHORT-COMBINATION-OPERATOR COMMON-LISP::NSUBLIS
+   PCL::GFS-OF-TYPE PCL::COPY-ACCESSOR-DFUN-INFO PCL::*MF1P*
+   COMMON-LISP::YES-OR-NO-P S::C-SET-HASHTABLE-SELF
+   PCL::METHOD-CLASS-NAME COMMON-LISP::INTERACTIVE-STREAM-P PCL::CAM
+   PCL::DEFSTRUCT-P PCL::ONE-INDEX-P PCL::ONE-ORDER-P
+   PCL::INTERN-FUNCTION-NAME PCL::SLOTD PCL::INSTANCE-BOUNDP
+   PCL::INSTANCE-WRITER S::C-FLOAT-FCOMPLEX-== S::C-FLOAT-DCOMPLEX-==
+   PCL::KNOWN-TYPE PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PV-CELL)|
+   PCL::NON-SETF-CASE PCL::BOTTOM PCL::SORT-CALLS PCL::MAKE-METHOD-SPEC
+   PCL::GCL_PCL_BOOT COMMON-LISP::SIMPLE-CONDITION-FORMAT-CONTROL
+   PCL::|(SETF GF-DFUN-STATE)| PCL::FAST-INSTANCE-BOUNDP- PCL::SPEC
+   PCL::R/W PCL::CONVERT-TABLE COMMON-LISP::CLOSE PCL::COLLECTING-ONCE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::CONSTANTS PCL::TWO-CLASS
+   PCL::TWO-CLASS- PCL::CLASS-SLOTDS PCL::.FAST-CALL-METHOD.
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LENGTH)| S::C-FLOAT-FLOAT-==
+   PCL::STD-CLASS PCL::GET-CACHE-VECTOR S::C-SET-FUNCTION-ARGD
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT 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::|(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::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::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::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::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::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|
+   PCL::SUPERCLASSES-COMPATIBLE-P PCL::SPECLS PCL::ARGLISTP
+   PCL::GCL_PCL_METHODS PCL::R+SNL PCL::GF-CALL-FORM S::*LONG
+   PCL::CONSTANT-VALUE- PCL::N-N-P PCL::GCL_PCL_DEFS PCL::INSTANCE-SET
+   PCL::EXTERNAL-COUNT COMMON-LISP::DELETE-FILE
+   COMMON-LISP::WITH-HASH-TABLE-ITERATOR PCL::DEFSTRUCT-CONSTRUCTOR
+   PCL::WALK-METHOD-LAMBDA COMMON-LISP::FLOAT PCL::CACHING-DFUN-INFO
+   COMMON-LISP::RENAME-FILE PCL::%%ALLOCATE-INSTANCE--CLASS PCL::SFORMS
+   PCL::BOOTSTRAP-SET-SLOT PCL::CACHE-MAX-LOCATION PCL::EXISTING
+   PCL::*SLOTD-READER-FUNCTION-STD-P* PCL::CLASSES-REV
+   COMMON-LISP::HASH-TABLE-REHASH-THRESHOLD PCL::NO PCL::FSC-INSTANCE-P
+   COMMON-LISP::DEFINE-CONDITION PCL::|(BOUNDP METHOD)|
+   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES
+   COMMON-LISP::RANDOM-STATE S::C-SET-PACKAGE-USELIST
+   S::C-SET-PACKAGE-USEDBYLIST COMMON-LISP::UPPER-CASE-P
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LIMIT-FN)|
+   PCL::*PRECOMPILING-LAP* PCL::RAISE-METATYPE
+   S::C-SET-PATHNAME-NAMESTRING COMMON-LISP::GO
+   PCL::ALLOCATE-CACHE-VECTOR PCL::ONE-INDEX-DFUN-INFO
+   PCL::USE-CACHING-DFUN-P COMMON-LISP::DO COMMON-LISP::GRAPHIC-CHAR-P
+   PCL::GCL_PCL_DFUN PCL::|(WRITER INITARGS)| PCL::PREDICATE-NAME-P
+   PCL::ADD-NAMED-METHOD PCL::COPY-STD-INSTANCE
+   PCL::BUILT-IN-WRAPPER-OF PCL::METHOD-FUNCTION-RETURNING-T
+   COMMON-LISP::PATHNAME-TYPE S::C/ PCL::ONE-INDEX-CACHE
+   COMMON-LISP::*PRINT-PPRINT-DISPATCH* PCL::MAKE-KEYWORD PCL::INITFORM
+   PCL::RFORMS PCL::MAP-ALL-ORDERS COMMON-LISP::STANDARD-CHAR
+   S::C-SET-HASHTABLE-CACHE COMMON-LISP::PROCLAIM
+   PCL::REMOVE-BOUNDP-METHOD COMMON-LISP::BLOCK PCL::NEW-VALUE-FORM
+   PCL::BUILT-IN-CLASS-SIMPLE-TYPEP-FN PCL::|PV-TABLE SLOT3|
+   S::C-SET-PATHNAME-TYPE PCL::CLASS-SYMBOL PCL::|CHECKING SLOT1|
+   COMMON-LISP::LOWER-CASE-P COMMON-LISP::// PCL::CASE-SYM PCL::BODY
+   PCL::TWO-CLASS-DFUN-INFO COMMON-LISP::READ-SEQUENCE PCL::KCL-PATCHES
+   PCL::EARLY-METHOD PCL::CACHED-COMBINED-INITARGS-FORM-LIST
+   PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME
+   PCL::METHOD-COMBINATION-DOCUMENTATION PCL::|__si::MAKE-MODULE|
+   PCL::|(WRITER INITIALIZE-INFO)| PCL::COMPUTE-APPLICABLE-KEYWORDS
+   COMMON-LISP::*PRINT-READABLY* PCL::LEGAL-CLASS-NAME-P
+   PCL::MAKE-A-METHOD PCL::REQUIRED-PARAMETER
+   PCL::FGEN-GENERATOR-LAMBDA PCL::|PV-TABLE SLOT2|
+   COMMON-LISP::CEILING COMMON-LISP::SIMPLE-BASE-STRING PCL::EMIT-DLAP
+   COMMON-LISP::NOT PCL::WRAPPER-FETCHER COMMON-LISP::PATHNAME-NAME
+   PCL::|PCL::TRACED-METHOD class predicate| PCL::GCL_PCL_FNGEN
+   COMMON-LISP::MULTIPLE-VALUE-BIND COMMON-LISP::*TRACE-OUTPUT*
+   PCL::WRAPPERS-REV PCL::EARLY-CLASS-PRECEDENCE-LIST-SYMBOL
+   PCL::COPY-FAST-INSTANCE-BOUNDP S::C-SET-HASHTABLE-STATIC
+   PCL::USE-PACKAGE-PCL PCL::CACHED-NAME PCL::.UMETHODS.
+   PCL::COMPUTE-CONSTANTS PCL::LINE-PRIMARY PCL::CALL-NO-NEXT-METHOD
+   PCL::DISPATCH-DFUN-COST COMMON-LISP::USE-PACKAGE PCL::SMETHODS
+   PCL::SLOT-WRITER-SYMBOL PCL::FOR-ACCESSOR-P S::C-SET-PATHNAME-NAME
+   S::C-SYMBOL-HPACK PCL::|(WRITER DEFSTRUCT-CONSTRUCTOR)|
+   PCL::|PV-TABLE SLOT1| PCL::GFS-TO-DO PCL::TRANSFORM PCL::TRANSFORMS
+   PCL::NAME-DECL S::C-PATHNAME-HOST
+   PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST COMMON-LISP::PATHNAME-DEVICE
+   PCL::GENERATOR-LAMBDA PCL::STANDARD-WRITER-METHOD-P
+   PCL::PORT-DIRECTORY PCL::FREE-OLD-CACHE-P COMMON-LISP::SUBSEQ
+   PCL::METATYPE S::C-ARRAY-HASFILLP S::C-SYMBOL-HASH
+   PCL::CHECK-LAMBDA-LIST
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLASSES
+   PCL::CLAUSE PCL::*NAME->CLASS->SLOTD-TABLE*
+   PCL::EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::INITARGS
+   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL 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::PLIST-P
+   COMMON-LISP::SET-EXCLUSIVE-OR COMMON-LISP::GENSYM
+   PCL::|(WRITER ARG-INFO)| COMMON-LISP::REALPART
+   S::C-SET-PATHNAME-DEVICE PCL::PLIST PCL::|(WRITER OPERATOR)|
+   PCL::|PV-TABLE SLOT0| COMMON-LISP::CODE-CHAR PCL::POS PCL::MLIST
+   S::C-SET-OCOMPLEX-REAL PCL::SKIP-FAST-SLOT-ACCESS-P
+   SYSTEM::STD-INSTANCE COMMON-LISP::FLOAT-RADIX PCL::TYPE-SYM
+   PCL::|DFUN-INFO SLOT0| PCL::ALLOC PCL::PRINT-CACHE
+   PCL::CLASSES-LIST-P COMMON-LISP::READ-CHAR COMMON-LISP::PEEK-CHAR
+   PCL::CACHE-LIMIT-FN COMMON-LISP::*DEBUGGER-HOOK*
+   COMMON-LISP::WRITE-SEQUENCE PCL::ALIST COMMON-LISP::BASE-CHAR
+   COMMON-LISP::NAME-CHAR COMMON-LISP::COS
+   COMMON-LISP::SET-MACRO-CHARACTER COMMON-LISP::GET-MACRO-CHARACTER
+   PCL::METHOD-COMBINATION-SIMPLE-TYPEP-FN PCL::MNAME
+   PCL::MAKE-DLAP-LAMBDA-LIST PCL::PROBE-CACHE PCL::KNX PCL::SPECL1
+   PCL::UNSPECIALIZED-LAMBDA-LIST S::C-RANDOM-STATE S::C-SYMBOL-STYPE
+   PCL::EXPAND-EMF-CALL-METHOD PCL::OPTIONS PCL::FNAME
+   COMMON-LISP::INPUT-STREAM-P PCL::C-A-M-GF
+   PCL::RAW-INSTANCE-ALLOCATOR PCL::DNAME PCL::LOAD-BINARY PCL::CNAME
+   PCL::CLASS-SLOT-P PCL::DEFSTRUCT-ACCESSOR-SYMBOL PCL::READERS-INIT
+   COMMON-LISP::*PRINT-PRETTY* PCL::|(SETF DOCUMENTATION)|
+   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::MAKE-EFFECTIVE-METHOD-FUNCTION1 PCL::COPY-CACHE
+   PCL::DECLARATION-SPECIFIERS COMMON-LISP::*PRINT-ARRAY* S::*SHORT
+   PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR PCL::*SLOT-UNBOUND*
+   PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE PCL::FDEFINE-CAREFULLY
+   SYSTEM::DEFCFUN PCL::FILL-CACHE PCL::BIND-FAST-LEXICAL-METHOD-MACROS
+   COMMON-LISP::*LOAD-VERBOSE* PCL::CLOE-LOW COMMON-LISP::FIND-IF
+   PCL::MAKE-CACHE PCL::SHOW-EMF-CALL-TRACE
+   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+   PCL::STANDARD-BOUNDP-METHOD-P PCL::GENERATE-DISCRIMINATION-NET
+   PCL::FOR S::*FLOAT COMMON-LISP::POSITION COMMON-LISP::MAKE-SEQUENCE
+   PCL::FIXUP PCL::METHOD-FUNCTION-METHOD
+   PCL::CACHED-DEFAULT-INITARGS-FUNCTION
+   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
+   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
+   PCL::GCL_PCL_ITERATE S::C-SYMBOL-NAME PCL::CANONICAL-SLOT
+   PCL::|(WRITER CLASS-EQ-SPECIALIZER)| PCL::DEFCONSTRUCTOR
+   PCL::%NO-PRIMARY-METHOD S::C-SET-PACKAGE-INTERNAL_FP
+   S::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::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
+   PCL::INITIALIZE-FORM-LIST PCL::|(READER INITARGS)|
+   COMMON-LISP::BOOLE-C2 PCL::RENEW-SYS-FILES
+   COMMON-LISP::SET-DISPATCH-MACRO-CHARACTER
+   COMMON-LISP::GET-DISPATCH-MACRO-CHARACTER SYSTEM::C-FCOMPLEX-==
+   SYSTEM::C-DCOMPLEX-== COMMON-LISP::COMPLEMENT S::C-SPICE-DUMMY
+   PCL::|SYSTEM:S-DATA SLOT9| PCL::MNAME-SYM PCL::COPY-ARG-INFO
+   PCL::COMPUTE-SLOT-ACCESSOR-INFO PCL::*SPECIALS*
+   COMMON-LISP::RESTART-CASE PCL::PV-BINDING1 COMMON-LISP::PAIRLIS
+   PCL::*ASV-BOUNDPS* PCL::EXTRA-P
+   PCL::|(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)|
+   PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::INITIALIZE-INFO-CACHED-SLOTS
+   PCL::INITIALIZE-INITFNS COMMON-LISP::*PRINT-LINES* PCL::CPL
+   PCL::LEGAL-SPECIALIZER-P PCL::INSTANCE-ACCESSOR-PARAMETER
+   COMMON-LISP::STANDARD-CHAR-P PCL::CACHE-COUNT
+   COMMON-LISP::*PRINT-LEVEL* PCL::PV-MAP PCL::MODE
+   PCL::|SYSTEM:S-DATA SLOT8| COMMON-LISP::ALPHA-CHAR-P
+   COMMON-LISP::SIXTH PCL::STANDARD-CLASS-P
+   PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS COMMON-LISP::*PRINT-RADIX*
+   PCL::CLOSURE-GENERATOR PCL::CODE PCL::|(WRITER WRAPPER)|
+   PCL::PROGN-FORM PCL::CONSTS PCL::|(READER INITIALIZE-INFO)|
+   COMMON-LISP::ARRAY-IN-BOUNDS-P PCL::INCLUDE PCL::ENV
+   PCL::GET-MAKE-INSTANCE-FUNCTION PCL::CNV PCL::|SYSTEM:S-DATA SLOT7|
+   PCL::OPTIONAL S::C-SYMBOL-SFDEF S::C-SYMBOL-GFDEF S::C-SYMBOL-MFLAG
+   COMMON-LISP::DEPOSIT-FIELD PCL::FIX-EARLY-GENERIC-FUNCTIONS
+   PCL::*EQL-SPECIALIZER-TABLE*
+   COMMON-LISP::*READ-DEFAULT-FLOAT-FORMAT*
+   PCL::EARLY-COLLECT-DEFAULT-INITARGS PCL::GET-WRAPPERS-FROM-CLASSES
+   PCL::OMETHOD PCL::TMETHOD
+   PCL::|(INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
+   PCL::DISPATCH-DFUN-INFO PCL::FALSE-CLAUSES PCL::EARLY-CLASS-NAME-OF
+   S::C-SYMBOL-DBIND PCL::.PV-TABLE. PCL::TOP COMMON-LISP::RATIONAL
+   PCL::|(READER DEFSTRUCT-CONSTRUCTOR)| COMMON-LISP::NOTANY
+   S::C-SET-PACKAGE-LINK PCL::DLINE PCL::SN COMMON-LISP::POP
+   COMMON-LISP::PPRINT PCL::ON COMMON-LISP::CONDITION
+   PCL::|SYSTEM:S-DATA SLOT6| PCL::OPTION COMMON-LISP::READTABLE
+   COMMON-LISP::READTABLEP PCL::METHOD-COMBINATION-TYPE
+   PCL::GCL_PCL_BRAID PCL::IN PCL::.NEXT-METHOD. PCL::FN SYSTEM::SEQIND
+   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::|(READER OPERATOR)| PCL::GET-INSTANCE-WRAPPER-OR-NIL S::C-T-PD1
+   SYSTEM::>> S::C-SET-PACKAGE-INTERNAL S::C-SET-PACKAGE-EXTERNAL
+   PCL::DO-STANDARD-DEFSETF-1 PCL::*CLASS-PV-TABLE-TABLE*
+   PCL::ALLOW-OTHER-KEYS PCL::|SYSTEM:S-DATA SLOT5|
+   PCL::DEFINE-DEFAULT-METHOD PCL::BOOTSTRAP-GET-SLOT PCL::INFO
+   COMMON-LISP::*PRINT-MISER-WIDTH* PCL::WRAPPERS+VALUE
+   PCL::|(SETF CLASS-DIRECT-SLOTS)| PCL::|(SETF CLASS-SLOTS)|
+   PCL::COMPUTE-LINE-SIZE PCL::WITHOUT-INTERRUPTS PCL::SCLASS
+   PCL::MAKE-DISPATCH-DFUN WALKER::VARIABLE-DECLARATION PCL::FAST-SYM
+   PCL::GET-WRAPPER-CACHE-NUMBER PCL::IF* PCL::INITIALIZE-INFO-WRAPPER
+   COMMON-LISP::DECLARE PCL::REAL-MF-P PCL::EXTRACT-DECLARATIONS
+   COMMON-LISP::SPECIAL PCL::OCACHE PCL::NO-OF-INSTANCE-SLOTS
+   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::CONS class predicate|
+   PCL::|COMMON-LISP::LIST class predicate|
+   PCL::|COMMON-LISP::SEQUENCE class predicate|
+   PCL::|COMMON-LISP::RATIO class predicate|
+   PCL::|COMMON-LISP::INTEGER class predicate|
+   PCL::|COMMON-LISP::RATIONAL class predicate|
+   PCL::|COMMON-LISP::REAL class predicate|
+   PCL::|COMMON-LISP::FLOAT class predicate|
+   PCL::|COMMON-LISP::COMPLEX class predicate|
+   PCL::|COMMON-LISP::NUMBER class predicate|
+   PCL::|COMMON-LISP::T class predicate|
+   PCL::|COMMON-LISP::FUNCTION class predicate|
+   PCL::|COMMON-LISP::STRUCTURE-OBJECT class predicate|
+   PCL::|COMMON-LISP::STANDARD-OBJECT class predicate|
+   PCL::|COMMON-LISP::BUILT-IN-CLASS class predicate| SYSTEM::ADDRESS
+   COMMON-LISP::GET-UNIVERSAL-TIME PCL::SLOT
+   PCL::CLASS-PROTOTYPE-SPECIALIZER
+   PCL::|(SETF CLASS-INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::SET-INITIAL-METHODS PCL::INITARGS-FUNCTION
+   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-METHOD-FUNCTION
+   PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION
+   PCL::INITIALIZE-INFO-COMBINED-INITIALIZE-FUNCTION
+   PCL::INITIALIZE-INFO-SHARED-INITIALIZE-NIL-FUNCTION
+   PCL::INITIALIZE-INFO-SHARED-INITIALIZE-T-FUNCTION
+   PCL::INITIALIZE-INFO-DEFAULT-INITARGS-FUNCTION
+   PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION PCL::INITIALIZE-FUNCTION
+   PCL::INITIALIZE-INSTANCE-METHODS COMMON-LISP::SHADOWING-IMPORT
+   PCL::DESCRIBE-SLOT PCL::TWO-CLASS-P
+   PCL::|(CALL REAL-MAKE-METHOD-LAMBDA)| PCL::PARAMETER-OR-NIL
+   PCL::VARIABLE-NAME PCL::UNDEFMETHOD-1 PCL::INSTANCE-REF SYSTEM::INT
+   PCL::COPY-PV PCL::INITARGS-FORM-LIST
+   PCL::|(SETF CLASS-DEFSTRUCT-FORM)| PCL::ONE-CLASS-DFUN-INFO
+   PCL::CLASS-AND-INITARGS PCL::|SYSTEM:S-DATA SLOT3|
+   PCL::WRAPPER-FIELD PCL::NCACHE COMMON-LISP::CLEAR-INPUT
+   PCL::1-OR-2-CLASS PCL::GET-EFFECTIVE-METHOD-FUNCTION1
+   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
+   PCL::COMPUTE-DEFAULT-INITARGS PCL::|(READER CLASS-EQ-SPECIALIZER)|
+   PCL::NCLASSES COMMON-LISP::SOFTWARE-VERSION PCL::.LAP-REST-ARG.
+   PCL::|SYSTEM:S-DATA SLOT2| PCL::DEFAULT-METHOD-ONLY PCL::EMIT
+   S::*USHORT PCL::CHECKING PCL::MAKE-ACCESSOR-DFUN-INFO
+   PCL::EMIT-IN-CHECKING-CACHE-P PCL::DO-SATISFIES-DEFTYPE
+   PCL::CHECK-APPLICABLE-KEYWORDS COMMON-LISP::LOAD
+   PCL::|(READER DEFSTRUCT-ACCESSOR-SYMBOL)| PCL::CANONICAL-OPTIONS
+   PCL::*MINIMUM-CACHE-SIZE-TO-LIST* PCL::SLOT-NAME-LISTS PCL::FMF-P
+   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL PCL::FNS COMMON-LISP::ENDP
+   COMMON-LISP::COPY-PPRINT-DISPATCH PCL::|SYSTEM:S-DATA SLOT1|
+   PCL::GF-INFO-C-A-M-EMF-STD-P COMMON-LISP::WITH-SIMPLE-RESTART
+   PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST PCL::|(READER WRAPPER)|
+   PCL::ALL-ARGS-P S::C-SET-PACKAGE-NAME SYSTEM::DOUBLE
+   PCL::STANDARD-GENERIC-FUNCTION-P PCL::STANDARD-READER-METHOD-P
+   PCL::STANDARD-METHOD-P PCL::*PORT+DNAME-LIST* PCL::DISPATCH-CACHE
+   PCL::|SYSTEM:S-DATA SLOT0| PCL::GOLD-PATCHES PCL::FUNCTION-FUNCALL
+   PCL::ALL-CLASS-LISTS PCL::EFFECTIVE-METHOD COMMON-LISP::LAMBDA
+   S::C-PATHNAME-TYPE COMMON-LISP::MAKE-SYNONYM-STREAM
+   PCL::*INITFUNCTIONS* PCL::CLASS-EQ
+   PCL::CLASS-APPLICABLE-USING-CLASS-P COMMON-LISP::LISTP PCL::SUBCLASS
+   COMMON-LISP::TERPRI COMMON-LISP::SATISFIES
+   PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P COMMON-LISP::BOOLE-ORC1
+   COMMON-LISP::BOOLE-ORC2 PCL::REST-ARG PCL::PCL-FAST-CALL
+   PCL::SPARAMETER PCL::CAN-OPTIMIZE-ACCESS1 PCL::ALLOCATION
+   COMMON-LISP::NUNION PCL::|(SETF CLASS-NAME)|
+   PCL::ARGUMENT-SPECIFIERS PCL::OPTIMIZE-GF-CALL-INTERNAL PCL::METHODS
+   PCL::EARLY-COLLECT-CPL COMMON-LISP::SLEEP PCL::CHECK-CACHE PCL::C-W
+   PCL::STANDARD-ACCESSOR-METHOD-P COMMON-LISP::NSUBSTITUTE
+   PCL::MAKE-BUILT-IN-CLASS-SUBS PCL::CHECK-WRAPPER-VALIDITY
+   PCL::WRAPPER-REF PCL::NOT-BEST-P PCL::*DEFAULT-INITARGS-FLAG*
+   COMMON-LISP::FIRST PCL::PARSE-SPEC COMMON-LISP::COMPLEX
+   S::C-ADJVECTOR-FILLP S::C-PATHNAME-NAME COMMON-LISP::UNTRACE
+   PCL::GMAKUNBOUND COMMON-LISP::FMAKUNBOUND PCL::CLOE
+   PCL::CACHE-MISS-VALUES PCL::N-N- PCL::FAST-METHOD-CALL-
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF
+   PCL::FIRST-WRAPPER-CACHE-NUMBER-INDEX PCL::FALSE-CASE-P
+   PCL::*IN-PRECOMPUTE-EFFECTIVE-METHODS-P*
+   PCL::*EARLY-CLASS-PREDICATES* PCL::ALL-SORTED-P
+   PCL::*OPTIMIZE-SLOT-BOUNDP* PCL::A-CLASSES
+   PCL::WRAPPER-INSTANCE-SLOTS-LAYOUT PCL::.DESTRUCTURE-FORM.
+   PCL::MCLASS PCL::MAKE-STD-INSTANCE COMMON-LISP::RPLACA
+   PCL::DFUN-ARG-SYMBOL PCL::BOOTSTRAP-BUILT-IN-CLASSES
+   COMMON-LISP::INSPECT COMMON-LISP::MULTIPLE-VALUE-PROG1
+   PCL::|(COMBINED-METHOD INITIALIZE-INSTANCE)|
+   PCL::|(COMBINED-METHOD REINITIALIZE-INSTANCE)| PCL::REL-7-2-PATCHES
+   PCL::TWO-CLASS-CACHE PCL::.CASE-ARG.
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2 PCL::CLASS-SLOT-CELLS
+   PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS PCL::GOLD-LOW
+   PCL::PROCLAIM-DEFMETHOD PCL::NKEYS PCL::AOK
+   COMMON-LISP::LOGICAL-PATHNAME PCL::TI-PATCHES
+   PCL::COMPILE-LAMBDA-UNCOMPILED COMMON-LISP::CLASS
+   PCL::WITH-DFUN-WRAPPERS PCL::MAX-COST-SO-FAR COMMON-LISP::INCF
+   PCL::SLOT-BOUNDP-SYMBOL PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 PCL::NM
+   PCL::|METHOD-CALL SLOT1| PCL::CHECK-INITARGS-2-PLIST
+   PCL::CHECK-INITARGS-2-LIST PCL::KEYS+AOK
+   PCL::|PCL::SPECIALIZER-WITH-OBJECT class predicate|
+   COMMON-LISP::LOOP-FINISH PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1
+   PCL::NO-PRIMARY-METHOD
+   PCL::|(COMBINED-METHOD COMPUTE-EFFECTIVE-METHOD)|
+   COMMON-LISP::DO-SYMBOLS COMMON-LISP::*ERROR-OUTPUT*
+   PCL::NOTE-PV-TABLE-REFERENCE S::C-
+   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION PCL::INITIALIZE-INFO-P
+   COMMON-LISP::>= PCL::LIMIT-FN PCL::MAKE-DIRECT-SLOTD COMMON-LISP::<=
+   PCL::MAKE-FAST-INSTANCE-BOUNDP PCL::NO-SLOT PCL::CMU
+   PCL::|METHOD-CALL SLOT0| PCL::VARIABLE-REBINDING
+   PCL::SYSTEM-SOURCE-FILES PCL::METHOD-P
+   PCL::DEAL-WITH-ARGUMENTS-OPTION PCL::BOOTSTRAP-CLASS-PREDICATES
+   COMMON-LISP::BOTH-CASE-P COMMON-LISP::/= COMMON-LISP::1-
+   PCL::MAKE-BINARY-PATHNAME COMMON-LISP::KEYWORDP
+   PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST PCL::N-N-DFUN-INFO
+   PCL::BUG-REPORT-INFO PCL::ALLOW-OTHER-KEYS-P PCL::LEGAL-QUALIFIER-P
+   COMMON-LISP::ROTATEF PCL::MAKE-FAST-METHOD-CALL
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY PCL::W-T
+   PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P
+   PCL::NUMBER-REQUIRED-ARGUMENTS PCL::FROB-COMBINED-METHOD-ARGS
+   PCL::HT-VALUE PCL::*MF2* PCL::S-DATA S::C-SET-SPICE-DUMMY PCL::K-T
+   PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::GF-CLASSES-TO-DO PCL::CPD
+   PCL::CONSTANT-SYMBOL-P PCL::*MF1* PCL::DEFAULT-METHOD-INITARGS
+   PCL::STRUCTURE-WRAPPER PCL::EARLY-COLLECT-INHERITANCE PCL::OLD-CACHE
+   PCL::MAKE-ACCESSOR-TABLE COMMON-LISP::WITH-CONDITION-RESTARTS
+   PCL::ONE-CLASS-P PCL::*THE-ESLOTD-FUNCALLABLE-STANDARD-CLASS-SLOTS*
+   PCL::*THE-ESLOTD-STANDARD-CLASS-SLOTS* PCL::*CLASS-EXPORTS*
+   PCL::*DESTRUCTURE-VARS* PCL::INVALID PCL::GET-CACHE PCL::NEW-CACHE
+   PCL::PV-CACHE-LIMIT-FN PCL::INITIAL-CLASSES-AND-WRAPPERS
+   S::C-ARRAY-ADJUSTABLE PCL::MAP-CACHE PCL::FLAGS
+   PCL::SLOT-CLASS-WRAPPER PCL::PV-BINDING PCL::DISPATCH-P
+   PCL::DISPATCH- PCL::C-A-M-EMF PCL::NMS PCL::MT-TAIL
+   PCL::*DFUN-CONSTRUCTORS* PCL::*STRUCTURE-TYPEP-COST*
+   PCL::CACHE-MISS-VALUES-INTERNAL PCL::CHECK-INITARGS-VALUES
+   PCL::.CALL-METHOD. PCL::OVERFLOW PCL::N-N-CACHE
+   PCL::MUTATE-SLOTS-AND-CALLS S::C-ARRAY-WRITABLE
+   PCL::DEFAULT-STRUCTUREP PCL::DECLARATIONS PCL::FIND-CLASS-CELL-CLASS
+   PCL::ADD-METHOD-DECLARATIONS PCL::UNPARSE COMMON-LISP::REMPROP
+   COMMON-LISP::LIST* COMMON-LISP::LONG-SITE-NAME COMMON-LISP::PACKAGEP
+   PCL::*BUILT-IN-OR-STRUCTURE-WRAPPER-TABLE*
+   COMMON-LISP::UNBOUND-VARIABLE COMMON-LISP::LOGIOR S::C-SYMBOL-PAD3
+   COMMON-LISP::INTERNAL-TIME-UNITS-PER-SECOND PCL::ENTRY-IN-CACHE-P
+   PCL::MAKE-ARG-INFO PCL::DEFAULT-METHOD-ONLY-DFUN-INFO
+   PCL::MAYBE-CHECK-CACHE PCL::INVALID-QUALIFIERS PCL::TYPES
+   PCL::EXPAND-SHORT-DEFCOMBIN PCL::GET-CACHE-FROM-CACHE PCL::LUCID-LOW
+   PCL::ONE-INDEX PCL::ONE-INDEX- S::C-SYMBOL-PAD2 PCL::ALL-INDEX
+   S::C-SET-MATRIX-DIMS COMMON-LISP::CALL-ARGUMENTS-LIMIT
+   PCL::CLASS-SLOT-P-CELL COMMON-LISP::APROPOS S::C-FUNCTION-ENV
+   COMMON-LISP::TYPEP COMMON-LISP::DPB PCL::PROTOTYPE PCL::SIZE
+   COMMON-LISP::CHECK-TYPE PCL::PYRAMID PCL::PARAM-INDEX
+   PCL::FUNCALLABLE-INSTANCE-DATA-1 PCL::MAP-INDEX PCL::GCLISP
+   COMMON-LISP::LOG COMMON-LISP::*READ-SUPPRESS*
+   PCL::NWRAPPER-CLASS-SLOTS PCL::OWRAPPER-CLASS-SLOTS
+   COMMON-LISP::*DEFAULT-PATHNAME-DEFAULTS*
+   PCL::RESET-INITIALIZE-INFO-INTERNAL PCL::QUALIFIER-CHECK-RUNTIME
+   PCL::GATHERER PCL::DEFINITION-SOURCE-MIXIN PCL::CLASS1 PCL::SNL
+   S::FUNCTION-ENV COMMON-LISP::NINTH PCL::MAKE-TYPE-PREDICATE-NAME
+   PCL::FINISH PCL::ARGUMENT-PRECEDENCE-ORDER-P PCL::*ASV-READERS*
+   PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::SLOT-CLASS-SIMPLE-TYPEP-FN
+   PCL::PROTO-GENERIC-FUNCTION PCL::GF-LL-NOPT PCL::COMPUTE-PRECEDENCE
+   PCL::STRUCTURE-SLOT-DESCRIPTION PCL::STRUCTURE-SLOTD-READER-FUNCTION
+   PCL::STRUCTURE-SLOTD-WRITER-FUNCTION PCL::STRUCTURE-SLOT-DEFINITION
+   PCL::EQ-P COMMON-LISP::THROW PCL::|PCL::MODULE class predicate|
+   PCL::VALUE-REG PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::SC1
+   PCL::ALL-SAME-P S::C-SET-T-CFW
+   PCL::|PCL::ONE-INDEX-DFUN-INFO class predicate|
+   PCL::GF-FAST-METHOD-FUNCTION-P COMMON-LISP::READTABLE-CASE
+   PCL::PLACE S::C-CFDATA-FILLP PCL::*FGENS* PCL::STORE-FGEN
+   COMMON-LISP::*LOAD-TRUENAME* PCL::TRANSFORMATIONS PCL::DASHES-P
+   COMMON-LISP::DEFPARAMETER PCL::DEFAULT-CONSTANTP PCL::NOPTIONAL
+   COMMON-LISP::&OPTIONAL PCL::EXTRA PCL::FUNCTION-NAMES
+   PCL::FORWARD-REFERENCED-CLASS-P PCL::GDEFINITION
+   COMMON-LISP::FDEFINITION PCL::.REST-ARG. COMMON-LISP::WRITE-CHAR
+   PCL::|PCL::DOCUMENTATION-MIXIN class predicate|
+   PCL::ALLOW-OTHER-KEYS-ARG COMMON-LISP::FLOAT-PRECISION
+   PCL::*SLOT-NAME-LISTS-OUTER* COMMON-LISP::FUNCTION-LAMBDA-EXPRESSION
+   PCL::.METHODS. COMMON-LISP::DOLIST PCL::SPECL-CPL
+   PCL::|(WRITER SLOTS)| PCL::BINARY PCL::SKIP-DFUN-UPDATE-P
+   S::C-FIXNUM-DOUBLE-== S::C-FCOMPLEX-FCOMPLEX-==
+   S::C-FCOMPLEX-DCOMPLEX-== S::C-DCOMPLEX-FCOMPLEX-==
+   S::C-DCOMPLEX-DCOMPLEX-== PCL::MODULE- COMMON-LISP::*PACKAGE*
+   PCL::USE-CONSTANT-VALUE-DFUN-P PCL::PL
+   PCL::|PCL::ONE-CLASS class predicate| PCL::COPY-TWO-CLASS PCL::LINES
+   COMMON-LISP::WILD-PATHNAME-P COMMON-LISP::IGNORABLE
+   PCL::*COMPILER-REENTRANT-P* PCL::LL PCL::*NOT-AN-EQL-SPECIALIZER*
+   COMMON-LISP::UNBOUND-SLOT-INSTANCE PCL::LIMIT
+   PCL::*SLOT-NAME-LISTS-INNER* PCL::|(WRITER PLIST)|
+   PCL::FIX-SLOT-ACCESSORS
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|
+   PCL::STRUCTURE-SLOTD-INIT-FORM COMMON-LISP::STRUCTURE-OBJECT
+   COMMON-LISP::WITH-COMPILATION-UNIT PCL::CL
+   PCL::STRUCTURE-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::WRAPPER-BINDINGS
+   S::C-FCOMPLEX-FLOAT-== S::C-DCOMPLEX-FLOAT-== S::+KS+
+   PCL::*BEING-LOADED* PCL::TO-LINE PCL::CACHE-MASK PCL::LINE-VALID-P
+   WALKER::*VARIABLE-DECLARATIONS* PCL::ONE-CLASS-CACHE
+   PCL::MAKE-EQL-PREDICATE SYSTEM::<< S::HASHTABLE-SELF
+   PCL::|(WRITER OBJECT)| PCL::|(WRITER TYPE)|
+   PCL::EXPAND-TIME-VAL-FORMS PCL::ENTRY-WRAPPERS PCL::NEW-TABLE-TABLE
+   COMMON-LISP::PACKAGE-ERROR-PACKAGE S::C-SET-T-MDIM
+   PCL::CLASS-SLOT-VALUE COMMON-LISP::FLET
+   PCL::*STANDARD-METHOD-COMBINATION* PCL::UNSUPPLIED PCL::TIMES
+   COMMON-LISP::WITH-PACKAGE-ITERATOR PCL::GET-METHOD-FUNCTION-PV-CELL
+   PCL::IBCL-PATCHES PCL::*UNSPECIFIC-ARG* PCL::*COMPILER-PRESENT-P*
+   PCL::|(WRITER CLASS)| S::C-SET-CFDATA-FILLP PCL::EFFECTIVE-P
+   PCL::*FEGF-DEBUG-P* PCL::|INITIALIZE-INFO SLOT9|
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION
+   PCL::*VARIABLE-DECLARATIONS-WITH-ARGUMENT*
+   PCL::*VARIABLE-DECLARATIONS-WITHOUT-ARGUMENT* PCL::*THE-PCL-PACKAGE*
+   ITERATE::GATHER PCL::INITARG-ERROR S::C-SET-ARRAY-HASFILLP
+   COMMON-LISP::MOD PCL::SUPERCLASS
+   PCL::*COMPUTE-STD-CPL-CLASS->ENTRY-TABLE-SIZE* PCL::*SGF-SLOTS-INIT*
+   PCL::VECTORIZING COMMON-LISP::ELT PCL::BOD
+   SYSTEM::NON-NEGATIVE-FIXNUM COMMON-LISP::MACHINE-INSTANCE
+   S::C-SET-STREAM-INT PCL::MAKE-TRANSFORMATIONS PCL::FN-LAMBDA
+   PCL::|INITIALIZE-INFO SLOT8| COMMON-LISP::HANDLER-CASE
+   S::C-PATHNAME-DIRECTORY COMMON-LISP::REMOVE PCL::GENERA-LOW
+   COMMON-LISP::FLOAT-SIGN PCL::MLOOKUP PCL::*EVAL-WHEN-COMPILE*
+   PCL::DEFAULT-INITARGS COMMON-LISP::LOGANDC1
+   PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::STRUCTURE-TYPE-P
+   COMMON-LISP::COERCE S::C-CFDATA-SIZE PCL::TYPE2
+   PCL::MODULE-RECOMP-REASONS PCL::NO-METHODS-P PCL::TYPE1 PCL::DO-IF
+   PCL::N-N S::C-FIXNUM-FIXNUM-== PCL::COMPLETE PCL::FILES
+   PCL::MAKE-FINAL-DFUN PCL::|INITIALIZE-INFO SLOT7|
+   PCL::CONSTANT-VALUE-MISS PCL::PLS PCL::DOCUMENTATION-MIXIN
+   COMMON-LISP::PACKAGE-NICKNAMES S::C-HASHTABLE-MAX_ENT PCL::LOC
+   COMMON-LISP::FIND-PACKAGE PCL::|PCL::SLOT-OBJECT class predicate|
+   PCL::DOC PCL::UPDATE-SLOT-VALUE-GF-INFO PCL::..SLOT-UNBOUND..
+   PCL::GCL_PCL_IMPL_LOW COMMON-LISP::LIST PCL::DEFINITION-SOURCE
+   PCL::INNER-RESULT. PCL::|INITIALIZE-INFO SLOT6| PCL::WITH-HASH-TABLE
+   PCL::MISS PCL::|(WRITER NAME)| COMMON-LISP::UNEXPORT
+   COMMON-LISP::LOGXOR PCL::|PCL::INITIALIZE-INFO class predicate|
+   PCL::SAUT-NOT-CLASS-EQ COMMON-LISP::BIT-ANDC1 S::C-FUNCTION-SELF
+   PCL::CLASS1-SUB PCL::OSLOTS PCL::WRAPPER PCL::DEFINITION-BEFORE-PCL
+   S::C-FIXNUM-FIXNUM-> PCL::FUNCTION-RETURNING-NIL
+   PCL::TYPE+COUNT+SIZES COMMON-LISP::ARRAY-RANK-LIMIT PCL::GFSPEC
+   S::C-STRUCTURE-SELF PCL::ERROR-P PCL::*NON-BUILT-IN-TYPEP-COST*
+   PCL::|INITIALIZE-INFO SLOT5| PCL::STRUCTURE-SLOTD-TYPE
+   PCL::*OPTIMIZE-ASV-FUNCALL-P* S::C-CFDATA-SELF PCL::QUALIFIERS
+   PCL::DEFAULT-METHOD-ONLY-CACHE PCL::|(READER SLOTS)|
+   S::C-FIXNUM-FLOAT-> PCL::SPECIFIER COMMON-LISP::POSITION-IF-NOT
+   PCL::VALID-KEYS COMMON-LISP::STYLE-WARNING PCL::LOAD-LONG-DEFCOMBIN
+   PCL::RI-VALID-P PCL::ADD-SLOT-ACCESSORS PCL::NSLOTS PCL::SEPARATE-P
+   PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME PCL::ACCESSOR-SLOT-BOUNDP
+   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|
+   PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| PCL::WITH
+   S::C-T-MELTTYPE PCL::|INITIALIZE-INFO SLOT4| PCL::|(READER PLIST)|
+   PCL::WRAPPER-CLASS* PCL::STRUCTURE-SVUC-METHOD PCL::COUNT-DFUN
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION2
+   COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM
+   COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM
+   PCL::REAL-MAKE-METHOD-LAMBDA PCL::ARG-INFO-LAMBDA-LIST
+   S::C-SET-CFDATA-SIZE PCL::CLASS-WRAPPER PCL::|(READER OBJECT)|
+   PCL::|(READER TYPE)| PCL::STRUCTURE-SLOTD-NAME PCL::*TRACED-METHODS*
+   COMMON-LISP::UNUSE-PACKAGE S::C-SET-ARRAY-ELTSIZE
+   COMMON-LISP::PRINT-NOT-READABLE PCL::LEGAL-SLOT-NAME-P
+   PCL::|INITIALIZE-INFO SLOT3| PCL::XEROX-PATCHES
+   PCL::LIST-LARGE-CACHES PCL::INVALID-WRAPPER-P
+   S::C-SET-STRUCTURE-SELF
+   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|
+   PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|
+   PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
+   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
+   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+   PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
+   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+   PCL::|(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::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION1 PCL::EARLY-MAKE-A-METHOD
+   PCL::IOA COMMON-LISP::VECTOR-POP PCL::OPERATE-ON-SYSTEM
+   PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::INITARGS-FORM
+   COMMON-LISP::MERGE-PATHNAMES PCL::WRAPPERS-P PCL::CLASS-PREDICATE
+   COMMON-LISP::BYTE PCL::WHOLE PCL::|(READER CLASS)|
+   PCL::SHOW-DFUN-CONSTRUCTORS COMMON-LISP::HASH-TABLE-SIZE
+   PCL::|INITIALIZE-INFO SLOT2| PCL::ARG-INFO-APPLYP
+   COMMON-LISP::KEYWORD SYSTEM::C-FIXNUM-== S::C-SET-STREAM-FP
+   PCL::INITARGS-TAIL PCL::MAKE-CLASS-PRECEDENCE-DESCRIPTION
+   PCL::REL-8-PATCHES COMMON-LISP::DIGIT-CHAR
+   PCL::MAKE-FORWARD-REFERENCED-CLASS-P PCL::CLASS-EQ-WRAPPER
+   PCL::GET-SLOTS-OR-NIL PCL::SLOT-VALUE-OR-DEFAULT
+   PCL::REMOVE-SLOT-ACCESSORS PCL::|INITIALIZE-INFO SLOT1|
+   S::C-SET-CFDATA-SELF PCL::AKEY COMMON-LISP::LENGTH
+   PCL::MAKE-DFUN-LAMBDA-LIST PCL::NEW-TYPE PCL::CMU-LOW PCL::OK
+   S::C-SET-ARRAY-SELF PCL::PV-TABLES PCL::GCL_PCL_FAST_INIT
+   PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::KLIST-TAIL
+   PCL::ALIST-TAIL PCL::*DEFCLASS-TIMES*
+   PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
+   COMMON-LISP::DO-EXTERNAL-SYMBOLS PCL::|INITIALIZE-INFO SLOT0|
+   PCL::SLOTS-INIT COMMON-LISP::CHAR<= SYSTEM::C+
+   PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION PCL::SLOT-DESCRIPTION-LIST
+   COMMON-LISP::&KEY PCL::MAYBE-OPTIMIZE-WRITER
+   PCL::WRAPPER-CACHE-NUMBER-VECTOR
+   PCL::LONG-METHOD-COMBINATION-ARGUMENTS-LAMBDA-LIST
+   COMMON-LISP::*READ-BASE* COMMON-LISP::CHAR-CODE-LIMIT
+   PCL::SYMBOL-OR-CONS-LESSP PCL::*PCL-PROCLAIM* S::C-T-MADJUSTABLE
+   PCL::EMIT-CHECKING-OR-CACHING PCL::MAKE-EARLY-GF
+   PCL::CLASS-EQ-SPECIALIZER-WRAPPER COMMON-LISP::1+
+   PCL::WRAPPER-CACHE-NUMBER S::C-FUNCTION-ARGD
+   PCL::CONSTANT-VALUE-DFUN-INFO PCL::*DFUN-ARG-SYMBOLS*
+   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::STRUCTURE-CLASS-WRAPPER PCL::ALL-APPLICABLE PCL::*FIND-CLASS*
+   PCL::MAYBE-OPTIMIZE-READER COMMON-LISP::BYTE-SIZE PCL::PYR-LOW
+   PCL::DESCRIBE-PACKAGE PCL::CM-ARGS S::C-SET-T-EMF
+   PCL::ALL-APPLICABLE-AND-SORTED-P PCL::TYPE-FUNCTION
+   PCL::SUPPLIED-SUPERS COMMON-LISP::FIFTH PCL::DO-CLASS PCL::GF-ARGS
+   PCL::MAKE-CHECKING-OR-CACHING-FUNCTION-LIST PCL::WRAPPERS
+   PCL::SUPPLIED-SLOTS PCL::SYMBOL-LESSP PCL::FORMS-LIST
+   PCL::*SLOTD-ALL-FUNCTION-STD-P* COMMON-LISP::&ENVIRONMENT
+   COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS
+   PCL::*STD-CAM-METHODS* PCL::LINE-SIZE PCL::NEXT-WRAPPER-FIELD
+   COMMON-LISP::AND PCL::GF-CLASS COMMON-LISP::STABLE-SORT
+   PCL::HP-HPLABS COMMON-LISP::CHAR-NOT-LESSP
+   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS PCL::GF-SPEC
+   S::C-SET-CONS-CDR PCL::FLAG PCL::PENDING-POPS PCL::WRAPPER-CACHE-NO
+   PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN
+   COMMON-LISP::BIT-EQV COMMON-LISP::CHAR/= S::C-SET-STREAM-MODE
+   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN COMMON-LISP::CHAR-UPCASE
+   PCL::|PCL::CACHE class predicate| S::C-SET-ARRAY-ELTMODE
+   COMMON-LISP::PPRINT-TAB S::C-SET-CONS-CAR S::C-SET-ARRAY-WRITABLE
+   S::C-SET-ARRAY-ADJUSTABLE PCL::INITIAL-DISPATCH-
+   PCL::INITIALIZE-INFO- PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER
+   PCL::FROM-CACHE-VECTOR PCL::MAKE-EARLY-ACCESSOR
+   PCL::CONSTANT-VALUE-P PCL::ECD-SUPERCLASS-NAMES COMMON-LISP::BIT-NOT
+   COMMON-LISP::IGNORE PCL::INC PCL::GCL_PCL_GENERIC_FUNCTIONS
+   COMMON-LISP::BIT-XOR ITERATE::INTERVAL
+   PCL::STRUCTURE-DIRECT-SLOT-DEFINITION-SIMPLE-TYPEP-FN
+   COMMON-LISP::MAKE-PACKAGE PCL::FREE-CACHE-VECTOR
+   PCL::PRECOMPILE-RANDOM-CODE-SEGMENTS PCL::LOCATION-VALID-P
+   PCL::WRAPPER-CACHE-NUMBER-ADDS-OK SYSTEM::TP8 PCL::CLASS-TEST
+   PCL::PV-TABLE PCL::CLASS-EQ-SPECIALIZER-SIMPLE-TYPEP-FN
+   PCL::WRAPPER-CACHE-NUMBER-MASK
+   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::ACCESSOR-DFUN-INFO
+   COMMON-LISP::EIGHTH PCL::|PCL::SLOT-DEFINITION class predicate|
+   PCL::ALLOC-P PCL::EXPAND-LONG-DEFCOMBIN PCL::GENERIC-FUNCTION-P
+   COMMON-LISP::MAKE-HASH-TABLE PCL::KEYSP COMMON-LISP::IN-PACKAGE
+   PCL::*NON-VARIABLE-DECLARATIONS* PCL::PRECOMPILE-IIS-FUNCTIONS
+   COMMON-LISP::TYPE COMMON-LISP::PPRINT-POP PCL::GF-TABLE
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-MACRO
+   PCL::CALL-NEXT-METHOD-BODY PCL::STRUCTURE-CLASS-SIMPLE-TYPEP-FN
+   PCL::FAST-INSTANCE-BOUNDP PCL::GENERIC-FUNCTION-NAME-P S::*INT
+   PCL::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
+   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::*THE-WRAPPER-OF-FLOAT* PCL::|(BOUNDP INITARGS)| PCL::FOUND-P
+   COMMON-LISP::SIGNUM PCL::*ACCESSORS* S::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::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-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::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
+   PCL::*THE-CLASS-SPECIALIZER* S::LISP-TYPE PCL::DFUN-TYPE
+   PCL::IMPROPER-LIST-HANDLER PCL::*SLOT-ACCESSOR-NAME-PACKAGE*
+   PCL::|CACHE SLOT11| S::C-HASHTABLE-RHSIZE S::C-HASHTABLE-SIZE
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DECLARATIONS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITIAL-METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
+   PCL::COPY-ONE-INDEX-DFUN-INFO PCL::|(BOUNDP INITIALIZE-INFO)|
+   PCL::ALL PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT* PCL::CACHING
+   COMMON-LISP::THIRD COMMON-LISP::BIT-IOR PCL::COMPUTE-STD-CPL-PHASE-3
+   PCL::*THE-WRAPPER-OF-INTEGER* PCL::COMPUTE-TEST COMMON-LISP::SINH
+   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::|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::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
+   PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::REBOUND?
+   PCL::*THE-WRAPPER-OF-FUNCTION* PCL::WRAPPER1
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PLIST)|
+   COMMON-LISP::STRING-LESSP PCL::SLOT-INITARGS PCL::THING PCL::LMF
+   PCL::EMIT-CONSTANT-VALUE PCL::KCL-LOW
+   PCL::LONG-METHOD-COMBINATION-SIMPLE-TYPEP-FN
+   PCL::|(BOUNDP DEFSTRUCT-CONSTRUCTOR)| PCL::FMF
+   COMMON-LISP::CHAR-NOT-EQUAL PCL::MAKE-CLASS-PREDICATE-NAME
+   PCL::COMPUTE-STD-CPL-PHASE-2 PCL::ADD-DIRECT-SUBCLASSES PCL::EMF
+   PCL::|(SETF SLOT-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-DEFINITION-INITFUNCTION)|
+   PCL::|(SETF SLOT-ACCESSOR-FUNCTION)| 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::BOOTSTRAP-ACCESSOR-DEFINITIONS1
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
+   PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OBJECT)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)| 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-ECHO-STREAM*
+   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM* PCL::CPL-ERROR
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
+   PCL::*PREVIOUS-NWRAPPERS* S::C-DOUBLE-FLOAT-==
+   PCL::|(BOUNDP ARG-INFO)| ITERATE::WHILE PCL::*THE-WRAPPER-OF-REAL*
+   PCL::KIND PCL::EMIT-ONE-CLASS-WRITER COMMON-LISP::COMPILED-FUNCTION
+   S::C-READTABLE-SELF PCL::|(BOUNDP OPERATOR)|
+   PCL::COMPUTE-STD-CPL-PHASE-1 PCL::UNPARSED-SPECIALIZERS
+   COMMON-LISP::LISP-IMPLEMENTATION-VERSION PCL::OWNER
+   PCL::MAKE-MODULES PCL::CACHING-P S::C-HASHTABLE-SELF
+   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)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::*SECONDARY-DFUN-CALL-COST* PCL::MAKE-DFUN-ARG-LIST
+   PCL::*REVERT-INITIALIZE-INFO-P* S::C-SET-STREAM-FD
+   S::C-PACKAGE-SHADOWINGS PCL::*THE-WRAPPER-OF-STRING* SYSTEM::TP5
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)| PCL::*BOOT-STATE*
+   PCL::*SGF-DFUN-STATE-INDEX* PCL::CACHE-OWNER PCL::RESET-PCL-PACKAGE
+   PCL::NEW-KEYS PCL::POSSIBLY-APPLICABLE COMMON-LISP::EXPT
+   PCL::LIST-LARGE-CACHE PCL::.METHOD-COMBINATION.
+   PCL::FORMAT-ARGUMENTS SYSTEM::C* PCL::*THE-CLASS-RATIONAL*
+   S::C-SET-READTABLE-SELF PCL::META-SPECIALIZER PCL::LOAD-DEFCLASS
+   PCL::TRUE-VALUE COMMON-LISP::FILL PCL::CACHED-SLOT-NAMES
+   PCL::ACCESSOR-NAMES COMMON-LISP::TIME PCL::THREAD
+   PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :DEFINITION-SOURCE :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION :FUNCTION :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   COMMON-LISP::COMPILER-MACRO-FUNCTION S::C-DOUBLE-DOUBLE->
+   PCL::METHOD-SYM PCL::NEW-NAME PCL::EMIT-ONE-CLASS-READER
+   PCL::ORIG-METHODS COMMON-LISP::PRINT-UNREADABLE-OBJECT PCL::VALUEP
+   PCL::LINE-VALUE S::C-PATHNAME-NAMESTRING PCL::ARG-NUMBER
+   PCL::DOCUMENTATION-P PCL::*THE-CLASS-NUMBER*
+   COMMON-LISP::NSUBST-IF-NOT COMMON-LISP::** PCL::CYCLE
+   PCL::CLASS-EQ-TEST PCL::*EMF-CALL-TRACE-SIZE*
+   PCL::COMBINED-INITARGS-FORM-LIST PCL::ADD-WRITER-METHOD
+   PCL::CONSTANT-VALUE-CACHE PCL::IMPROPER-LIST PCL::WRITER-NAMES
+   PCL::NO-METHODS PCL::DO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
+   S::C-READTABLE-CASE PCL::METAOBJECT-SIMPLE-TYPEP-FN
+   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* S::C-SET-READTABLE-CASE
+   PCL::.CACHE. PCL::ACCESSOR-SET-SLOT-VALUE
+   PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
+   PCL::DEPENDENT-UPDATE-MIXIN-SIMPLE-TYPEP-FN PCL::*EMF-CALL-TRACE*
+   PCL::NLINES COMMON-LISP::PPRINT-TABULAR COMMON-LISP::TRUNCATE
+   COMMON-LISP::SYMBOL-VALUE PCL::PV-TABLE-LOOKUP PCL::.DFUN-REST-ARG.
+   COMMON-LISP::BIT-ORC1 PCL::FILE
+   PCL::|(BOUNDP DEFSTRUCT-ACCESSOR-SYMBOL)| PCL::NEXT-METHOD-P-BODY
+   S::C-FLOAT-FLOAT-> PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)| PCL::MIF-KEY
+   COMMON-LISP::IMAGPART PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD*
+   PCL::*THE-CLASS-STANDARD-WRITER-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
+   S::C-STRUCTURE-DEF PCL::EXACT-CLASS-SPECIALIZER-SIMPLE-TYPEP-FN
+   PCL::DIRECT-SUBCLASSES PCL::CHECK-FUNCTION S::C-SET-RATIO-NUM
+   PCL::SORTED-CALLS PCL::*FREE-CACHE-VECTORS* PCL::WRITER-SYMBOL
+   PCL::SLOTS-TO-INSPECT PCL::FMC-FUNCALL PCL::EMF-FUNCALL SYSTEM::TP3
+   PCL::SMC PCL::PV-TABLE-SLOT-NAME-LISTS
+   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN
+   PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN
+   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN PCL::MAKE-FINAL-CACHING-DFUN
+   PCL::MAKE-FINAL-DISPATCH-DFUN PCL::MAKE-FINAL-CHECKING-DFUN
+   PCL::MAKE-FINAL-ACCESSOR-DFUN PCL::MODULE-COMP-ENV
+   PCL::MODULE-LOAD-ENV PCL::LOAD-DEFMETHOD-INTERNAL PCL::SETQS
+   PCL::NMC PCL::EMIT-MISS PCL::|(BOUNDP WRAPPER)| S::C-SET-FUNCTION-VV
+   PCL::*LAZY-DFUN-COMPUTE-P* PCL::SORT-METHODS
+   PCL::*THE-CLASS-READTABLE* PCL::*THE-CLASS-HASH-TABLE*
+   COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS PCL::COMPILE-FILTER
+   PCL::NEW-ICUI S::C-T-MDIM PCL::PV-TABLE-PV-SIZE PCL::ALLOCATE
+   COMMON-LISP::SYMBOL-PACKAGE PCL::MAKE-PROGN PCL::CONSTANT-VALUE
+   PCL::TO-CACHE PCL::LMF-PARAMS PCL::*EQ-CASE-TABLE-LIMIT*
+   PCL::COPY-INITIALIZE-INFO PCL::TESTS
+   PCL::REAL-METHOD-COMBINATION-ERROR S::C-HASHTABLE-CACHE PCL::GET-VAL
+   PCL::SET-VAL S::C-PATHNAME-DEVICE COMMON-LISP::SVREF
+   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::FIX PCL::CLASS-CONSTRUCTORS
+   PCL::PVREF PCL::INVOKE-FAST-METHOD-CALL PCL::{METHOD-QUALIFIER}*
+   PCL::FORMAT-ARGS PCL::FINISH-PUSHING-INITARGS
+   PCL::FORMAT-CYCLE-REASONS PCL::STD-MI-METH PCL::STD-SI-METH
+   PCL::STD-II-METH PCL::METHOD-GROUP-SPECIFIERS PCL::PROPERTY-LIST
+   PCL::PV-TABLE-LOOKUP-PV-ARGS PCL::RESTP PCL::K+M
+   PCL::MAKE-INSTANCE-FUNCTION-SIMPLE SYSTEM::TP2 PCL::GBOUNDP
+   COMMON-LISP::FBOUNDP COMMON-LISP::BUTLAST
+   COMMON-LISP::MOST-NEGATIVE-FIXNUM PCL::.APPLICABLE-METHODS.
+   PCL::ONCE-ONLY PCL::VAXLISP S::C-ARRAY-OFFSET
+   PCL::|PCL::DIRECT-SLOT-DEFINITION class predicate|
+   PCL::NLINES-OR-CACHE-VECTOR PCL::MAKE-EFFECTIVE-METHOD-FUNCTION
+   PCL::ORDER-SPECIALIZERS PCL::SIMPLE-LEXICAL-METHOD-FUNCTIONS
+   PCL::SPECIALIZER-CACHES COMMON-LISP::MOST-NEGATIVE-SHORT-FLOAT
+   COMMON-LISP::MOST-NEGATIVE-SINGLE-FLOAT
+   COMMON-LISP::MOST-NEGATIVE-DOUBLE-FLOAT
+   COMMON-LISP::MOST-NEGATIVE-LONG-FLOAT PCL::STRUCTURE-TYPE
+   COMMON-LISP::FIND-RESTART PCL::WRAPPED-BODY
+   COMMON-LISP::INTERSECTION S::C-MATRIX-DIMS PCL::CLASS-FROM-TYPE
+   COMMON-LISP::SEVENTH COMMON-LISP::SET-PPRINT-DISPATCH
+   S::C-HASHTABLE-STATIC COMMON-LISP::DENOMINATOR
+   COMMON-LISP::CHAR-LESSP S::C-SET-RATIO-DEN PCL::DOLIST-CAREFULLY
+   PCL::RESTL COMMON-LISP::OUTPUT-STREAM-P S::C-PACKAGE-NICKNAMES
+   PCL::DEFINITION PCL::COMBINED-INITIALIZE-FUNCTION PCL::CACHE-NKEYS
+   COMMON-LISP::INTERN PCL::CLASS1-SUBS COMMON-LISP::INVOKE-DEBUGGER
+   COMMON-LISP::MINUSP S::C-T-MRANK PCL::GCL_PCL_DEFCOMBIN
+   PCL::NEW-DFUN-WRAPPERS-TAIL PCL::*INITIALIZE-INSTANCE-SIMPLE-ALIST*
+   PCL::BIW COMMON-LISP::MAKE-TWO-WAY-STREAM PCL::UPDATE-GF-INFO
+   PCL::STD-INSTANCE-SLOTS PCL::DIRECT-SLOT PCL::*ASV-WRITERS*
+   PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER PCL::TRY-ONE-FILL
+   S::C-SET-FUNCTION-PLIST PCL::XEROX PCL::EQL-SPECIALIZER-OBJECT
+   COMMON-LISP::DYNAMIC-EXTENT PCL::.SHES-NOT-THERE.
+   PCL::CACHED-RI-VALID-P COMMON-LISP::CONCATENATED-STREAM
+   PCL::UPDATE-INITIALIZE-INFO-CACHE S::C-DOUBLE-FCOMPLEX-==
+   S::C-DOUBLE-DCOMPLEX-== PCL::PROPER-EXTENSIONS
+   PCL::STD-INSTANCE-CLASS PCL::EXPAND-CACHE PCL::SYM2
+   COMMON-LISP::RESTART S::C-SET-T-W PCL::TRACE-EMF-CALL-INTERNAL
+   COMMON-LISP::LAMBDA-LIST-KEYWORDS SYSTEM::TP1
+   PCL::INVOKE-METHOD-CALL PCL::ALLOCATE-FUNCALLABLE-INSTANCE-SLOTS
+   PCL::*CACHE* PCL::SYM1 PCL::SLOT-DEFINITION-CLASS
+   PCL::ALL-GENERIC-FUNCTIONS PCL::BOUNDP-SYMBOL PCL::DOPLIST
+   COMMON-LISP::INTEGERP PCL::EMIT-DEFAULT-ONLY-FUNCTION
+   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::CALL-METHOD-LIST PCL::CLASS-METHOD-INITARGS
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::OFFSET)|
+   PCL::WRAPPER-CACHE-NUMBER-VECTOR-REF PCL::CLASS-NAME-OF
+   S::C-SET-T-ST PCL::METHOD2 PCL::*ALL-PV-TABLE-LIST*
+   PCL::FSC-INSTANCE-SLOTS PCL::SORTER PCL::NEW-DEFINITION
+   S::C-STREAM-INT S::C-STREAM-FP PCL::OTYPE PCL::SUBFORM
+   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| PCL::NTYPE
+   PCL::POS-FORM COMMON-LISP::MAPLIST COMMON-LISP::FILE-AUTHOR
+   PCL::FSC-INSTANCE-CLASS PCL::EMIT-READER/WRITER-FUNCTION PCL::OUTER
+   PCL::PV-TABLE-SYMBOL PCL::PV-INDEX
+   PCL::*INITIALIZE-INFO-CACHE-CLASS* PCL::SET-SLOT-VALUE
+   PCL::INDEX+TYPE COMMON-LISP::SCALE-FLOAT COMMON-LISP::FTYPE
+   COMMON-LISP::READ-DELIMITED-LIST
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT VALUEP)|
+   COMMON-LISP::COPY-TREE COMMON-LISP::UNREAD-CHAR
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PORT)| COMMON-LISP::ZEROP
+   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::UNCOMPILED COMMON-LISP::STRING-UPCASE
+   COMMON-LISP::STRING-DOWNCASE S::C-T-MHASFILLP PCL::GF-DFUN-INFO
+   PCL::POP-INTO
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::NO-EMIT)|
+   S::C-SET-T-M S::C-SET-T-MF COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE
+   PCL::NEW-FIELD SYSTEM::TP0 PCL::MAKE-PLIST COMMON-LISP::FTRUNCATE
+   PCL::METHOD1 PCL::TI PCL::SI PCL::MEMF-TEST-CONVERTER
+   PCL::OCLASS-SLOT-AND-VAL PCL::GATHER1 PCL::SET-MF-PROPERTY
+   COMMON-LISP::ARRAY-ELEMENT-TYPE COMMON-LISP::ALPHANUMERICP
+   COMMON-LISP::PI PCL::CONTEXT COMMON-LISP::MAP-INTO
+   PCL::EARLY-GF-METHODS PCL::MAKE-STRUCTURE-OBJECT PCL::LIST-PV
+   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)|
+   S::C-SET-STREAM-OBJECT1 PCL::FORWARD-CLASS PCL::SAUT-NOT-EQL
+   COMMON-LISP::PROVIDE PCL::SLOT-REGS
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)| PCL::BY
+   S::C-ARRAY-RANK PCL::DI PCL::*DEFMETHOD-TIMES* PCL::IIS-BODY
+   PCL::DEFINE-INITIALIZE-INFO S::C-SET-CHARACTER-CODE
+   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::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 COMPILER::RETURN-TYPE)|
+   PCL::*SUBTYPEP PCL::EMF-TYPE S::C-SET-T-E S::C-SET-HASHTABLE-TEST
+   S::C-T-MWRITABLE PCL::CONVERTED PCL::STD-INSTANCE-WRAPPER
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION READERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION WRITERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT NKEYS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
+   S::C-SET-STREAM-OBJECT0 PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
+   S::C-FUNCTION-NEVAL PCL::EQL-SPECIALIZER-SIMPLE-TYPEP-FN
+   PCL::ONE-INDEX-INDEX PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|
+   PCL::SLOTS-TO-REVERT PCL::NUMBER-REQUIRED
+   PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DOCUMENTATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-DEFINITION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD FAST-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ALLOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
+   PCL::|(FAST-READER-METHOD TRACED-METHOD FUNCTION)|
+   PCL::|(FAST-READER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT MAX-LOCATION)|
+   PCL::DIRECT-SLOTDS PCL::MAKE-SHORT-METHOD-COMBINATION
+   PCL::PLIST-MIXIN COMMON-LISP::SIMPLE-VECTOR PCL::CALL-SPEC
+   PCL::*ENABLE-EMF-CALL-TRACING-P* PCL::CM-ARGS1
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL
+   PCL::|(FAST-READER-METHOD 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-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::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 S::C-CONS-CAR PCL::HIT
+   PCL::*KEYWORD-PACKAGE*
+   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
+   PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::WHY PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
+   S::ADJUSTABLE-VECTOR COMMON-LISP::NBUTLAST
+   PCL::CALL-NEXT-METHOD-BIND PCL::SLOT-INSTANCE
+   PCL::|SYSTEM::S-DATA class predicate| PCL::CHECK-DOCUMENTATION
+   COMMON-LISP::BIT PCL::DIRECT-SUPERCLASSES-P PCL::CONC-NAME
+   PCL::SUPER-SLOTS PCL::NEXT-LINE COMMON-LISP::READ-LINE
+   PCL::RECOMP-REASONS PCL::SLOT-NAME PCL::SLOT-NAMES
+   PCL::FIND-SUPERCLASS-CHAIN PCL::CHASE PCL::FAST-METHOD-CALL-FUNCTION
+   PCL::|ARG-INFO SLOT8| S::C-SET-HASHTABLE-NENT PCL::PV-OFFSET
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
+   COMMON-LISP::HASH-TABLE-COUNT COMMON-LISP::CHAR-NAME
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LENGTH)| PCL::EVAL-FORM
+   PCL::%CCLOSURE-ENV-NTHCDR PCL::GET-EFFECTIVE-METHOD-GENSYM
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT NEXT-METHOD-CALL)|
+   PCL::EQL-OBJECT COMMON-LISP::TYPE-ERROR PCL::PATTERN
+   COMMON-LISP::ARITHMETIC-ERROR-OPERATION COMMON-LISP::*MODULES*
+   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 MASK)| PCL::CHECK-MEMBER
+   PCL::COPY-INITIAL-DISPATCH PCL::MAKE-METHOD-FUNCTION
+   PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-ENTRY-FN
+   PCL::METAOBJECT PCL::DEPTH PCL::KEYS PCL::SAME-SPECIALIZER-P
+   COMMON-LISP::CHAR-EQUAL PCL::READ-FORM PCL::WRAPPER-OF-MACRO
+   COMMON-LISP::FILE-ERROR PCL::CPL-INCONSISTENT-ERROR PCL::ALL-KEYS
+   PCL::|ARG-INFO SLOT7| COMMON-LISP::SUBSTITUTE WALKER::WALK-FORM
+   S::C-SET-T-PD1 COMMON-LISP::LOGEQV COMMON-LISP::CELL-ERROR
+   PCL::CACHE-VALUEP PCL::CONVERT-METHODS PCL::MAKE-CONSTANT-VALUE
+   COMMON-LISP::ARRAY-ROW-MAJOR-INDEX
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE PCL::DIFF PCL::REQ-ARGS
+   PCL::LOAD-DEFMETHOD PCL::NFIELD PCL::CHAIN PCL::EMIT-SLOT-ACCESS
+   COMMON-LISP::DEFINE-MODIFY-MACRO PCL::DOC-TYPE PCL::COMBINED-METHOD
+   PCL::INITIAL-P PCL::GF-PRETTY-ARGLIST
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FIELD)| PCL::OTHER-CLASS
+   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)|
+   COMMON-LISP::MERGE COMMON-LISP::CHAR> PCL::STRING-LOC
+   S::C-ARRAY-ELTTYPE PCL::UNTRACE-METHOD PCL::BEEN-HERE
+   PCL::MAIN-EFFECTIVE-METHOD COMMON-LISP::CHAR= PCL::AUGMENT-TYPE
+   PCL::NEXT PCL::PORT-DEVICE S::C-T-EMF PCL::SDFUN-FOR-CACHING
+   COMMON-LISP::NSTRING-CAPITALIZE PCL::*INVALID-METHOD-ERROR*
+   COMMON-LISP::CHAR< PCL::COLLECT
+   PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE
+   COMMON-LISP::PPRINT-DISPATCH PCL::UNDEFMETHOD PCL::IN-THE-COMPILER-P
+   COMMON-LISP::QUOTE COMMON-LISP::MULTIPLE-VALUE-SETQ
+   PCL::CLASS-DEFSTRUCT-FORM PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST
+   PCL::|ARG-INFO SLOT5| S::C-SET-T-MELTSIZE PCL::NO-CLASS-SLOTS-P
+   PCL::INCLUDED-NAME PCL::SUPER PCL::MAKE-ONE-INDEX-DFUN-INFO
+   COMMON-LISP::READ-BYTE PCL::SPECIALIZED-POSITIONS
+   PCL::SPECIALIZED-ARGUMENT-POSITIONS COMMON-LISP::COMPILE-FILE
+   PCL::PSYMS PCL::ARGLIST PCL::MAKE-METHOD-INITARGS-FORM
+   COMMON-LISP::REQUIRE
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LIMIT-FN)|
+   COMMON-LISP::MEMBER-IF PCL::CLASS-EQ-TYPE PCL::CHECK-METHOD-ARG-INFO
+   PCL::*CREATE-CLASSES-FROM-INTERNAL-STRUCTURE-DEFINITIONS-P* PCL::DIR
+   S::C-PACKAGE-INTERNAL_SIZE PCL::OINDEX PCL::WFT-TYPE2
+   PCL::COMPILE-MODULE COMMON-LISP::UNSIGNED-BYTE PCL::DEFINITE-P
+   COMMON-LISP::ASSERT PCL::PKG PCL::METHOD-ALLOW-OTHER-KEYS
+   S::C-SET-T-MWRITABLE PCL::WRITERS PCL::EXPAND-DEFGENERIC
+   S::C-SET-ARRAY-DIM PCL::|ARG-INFO SLOT4| PCL::TEST-FUNCTION
+   PCL::*EMIT-FUNCTION-P* COMMON-LISP::VECTOR SYSTEM::CLINES
+   PCL::NEXT-METHODS COMMON-LISP::TENTH PCL::CNM-METHODS S::C-T-FW
+   PCL::CACHED-NEW-KEYS PCL::|COMPILER::FN SLOT8| PCL::CHECKING-CACHE
+   COMMON-LISP::LISTEN PCL::CONTENDERS
+   COMMON-LISP::MULTIPLE-VALUES-LIMIT
+   PCL::|STRUCTURE-OBJECT class constructor| PCL::ORDER-CLEANUPS
+   PCL::GENERATOR-ENTRY COMMON-LISP::BIGNUM COMMON-LISP::LIST-LENGTH
+   PCL::SET-P S::C-SET-FUNCTION-MAXARG PCL::MAKE-SPECIALIZABLE
+   PCL::ARGUMENT PCL::DIRECT COMMON-LISP::WRITE-TO-STRING
+   PCL::|ARG-INFO SLOT3| PCL::NINDEX COMMON-LISP::FROUND PCL::DUMMY
+   PCL::NICK COMMON-LISP::PRIN1-TO-STRING COMMON-LISP::PRINC-TO-STRING
+   PCL::CACHE-NUMBER-VECTOR-REF PCL::SPECIALIZER-METHOD-TABLE
+   COMMON-LISP::FILE-LENGTH PCL::WRAPPER-OF PCL::DUPLICATE-OPTION
+   PCL::NET-TEST-CONVERTER PCL::METHOD-ARGS COMMON-LISP::APROPOS-LIST
+   PCL::|COMPILER::FN SLOT7| PCL::DISCARDED-SLOTS
+   PCL::EARLY-METHOD-QUALIFIERS COMMON-LISP::*LOAD-PATHNAME*
+   PCL::CACHED-CONSTANTS PCL::SETF-VAR PCL::MODIFY-CACHE
+   PCL::PV-OFFSET-FORM PCL::MAKE-DEFAULT-INITARGS-FORM-LIST
+   COMMON-LISP::REMOVE-IF-NOT S::C-SET-ADJVECTOR-FILLP PCL::INDEX-FORM
+   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR PCL::GCL_PCL_LOW
+   COMMON-LISP::PARSE-ERROR PCL::%INSTANCE-REF ITERATE::LIST-ELEMENTS
+   PCL::|ARG-INFO SLOT2| PCL::GET-KEY-ARG-TAIL
+   COMMON-LISP::DOUBLE-FLOAT-EPSILON
+   COMMON-LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON PCL::READER-NAMES
+   PCL::CHECK-SPECIALIZERS PCL::INITIALIZE-INFO
+   COMMON-LISP::FILE-STRING-LENGTH PCL::ALLOCATE-INSTANCE-METHODS
+   COMMON-LISP::STRING-NOT-LESSP PCL::FIN-LAMBDA-FN
+   PCL::MAKE-DEFMETHOD-FORM COMMON-LISP::PACKAGE-ERROR
+   PCL::EMIT-FETCH-WRAPPER PCL::INTERN-PV-TABLE PCL::ALL-CPDS
+   COMMON-LISP::DELETE-IF-NOT PCL::SPECIALIZER-CACHE S::STRCAT
+   PCL::CNM-ARGS PCL::PV-TABLE-CACHE COMMON-LISP::MEMBER-IF-NOT
+   PCL::|COMPILER::FN SLOT6| PCL::VALUE-FOR-CACHING PCL::ADD-TO-CVECTOR
+   PCL::UNTRACE-1 PCL::MAKE-METHOD-FUNCTION-INTERNAL
+   PCL::MAKE-METHOD-LAMBDA-INTERNAL
+   PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL COMMON-LISP::LONG-FLOAT
+   COMMON-LISP::SIMPLE-VECTOR-P S::C-STREAM-MODE PCL::DFUN-INFO-CACHE
+   COMMON-LISP::ECHO-STREAM-INPUT-STREAM
+   COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM S::C-SET-FUNCTION-MINARG
+   COMMON-LISP::ARRAY-RANK COMMON-LISP::LAMBDA-PARAMETERS-LIMIT
+   PCL::FIRST-FORM-TO-LISP PCL::NOT-IN-CACHE PCL::DEFSTRUCT-FORM
+   PCL::|ARG-INFO SLOT1| PCL::GF-DFUN-CACHE PCL::SPECL+SLOTD-LIST
+   PCL::GF-ARG-INFO S::C-STREAM-FD S::C-FLOAT-FIXNUM-==
+   PCL::LAMBDA-EXPRESSION PCL::SHORT-METHOD-COMBINATION-P
+   PCL::GCL_PCL_ENV COMMON-LISP::DEFVAR PCL::WRAPPER-EQ
+   PCL::LINE-FULL-P PCL::|COMPILER::FN SLOT5| PCL::FUNCALLABLE
+   PCL::NO-OF-SLOTS COMMON-LISP::DEFSTRUCT S::C-PACKAGE-EXTERNAL_SIZE
+   PCL::.FUNCTION. PCL::CFUNCTION PCL::TFUNCTION PCL::OFUNCTION
+   PCL::DEFAULT-INITARGS-1 COMMON-LISP::DEFINE-COMPILER-MACRO
+   PCL::ARG-INFO PCL::|ARG-INFO SLOT0| PCL::FAST-METHOD-CALL-P
+   PCL::|(WRITER OPTIONS)| PCL::|(WRITER METHODS)| COMMON-LISP::BOOLEAN
+   S::C-SET-ADJARRAY-DISPLACED COMMON-LISP::SUBTYPEP
+   PCL::%CHECK-CNM-ARGS S::C-CHARACTER-CODE
+   PCL::STD-CLASS-SIMPLE-TYPEP-FN PCL::READER-SYMBOL
+   S::C-SET-T-MHASFILLP PCL::|COMPILER::FN SLOT4| S::*DOUBLE
+   COMMON-LISP::EVERY PCL::METHOD-LAMBDA-ARGS
+   PCL::ONE-INDEX-DFUN-INFO-INDEX S::C-FLOAT-FIXNUM->
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
+   PCL::INSTANCE-SLOTS PCL::OBJECTSP PCL::DFUN-INFO PCL::DFUN-INFO-
+   PCL::FILENAMES PCL::SETF-CASE
+   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::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 S::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::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VECTOR)|
+   PCL::GET-GENERIC-FUNCTION-INFO COMMON-LISP::DELETE-DUPLICATES
+   PCL::|(FAST-WRITER-METHOD SLOT-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 S::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-READER-FUNCTION)|
+   PCL::|(WRITER INTERNAL-WRITER-FUNCTION)| PCL::GET-METHOD
+   PCL::NEW-METHOD PCL::|COMPILER::FN SLOT2|
+   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::RAND-BASE
+   COMMON-LISP::ADJUSTABLE-ARRAY-P PCL::CLASSES-LIST
+   PCL::RETURN-VALUE-P PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)|
+   PCL::.FAST-CALL-METHOD-LIST. PCL::METHOD-CALL-CALL-METHOD-ARGS
+   PCL::|(WRITER METHOD-CLASS)| PCL::OPERATION-TRANSFORMATIONS
+   PCL::IGNORE2 PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NLINES)|
+   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| PCL::|__si::MAKE-DFUN-INFO|
+   PCL::|__si::MAKE-ARG-INFO| PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|
+   PCL::METHOD-CALL COMMON-LISP::/// S::C-SET-PATHNAME-VERSION
+   PCL::CPD-COUNT PCL::MODULE-P PCL::MAKE-INITIALIZE-INFO
+   COMMON-LISP::APPEND PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OWNER)|
+   PCL::OLD-COUNT PCL::WRAPPER-1 PCL::RWALK COMMON-LISP::SIN
+   COMMON-LISP::RASSOC-IF-NOT PCL::CONSTANT
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::HAS-HOLES)|
+   COMMON-LISP::FRESH-LINE PCL::CACHED-NAMES PCL::WALKED-DECLARATIONS
+   PCL::EMPTYP COMMON-LISP::SET-SYNTAX-FROM-CHAR COMMON-LISP::MIN
+   PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION COMMON-LISP::SETQ
+   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
+   PCL::DEFINE-GF-PREDICATE S::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::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
+   COMMON-LISP::BROADCAST-STREAM PCL::INCOMPATIBLE-SUPERCLASS-LIST
+   PCL::DO-READER-DEFINITION PCL::SLOT-CLASS-P PCL::TEST
+   PCL::EXTRACT-PARAMETERS COMMON-LISP::REST COMMON-LISP::EVENP
+   PCL::CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::METHOD-CLASS-SUPPLIED-P COMMON-LISP::STRING-NOT-EQUAL
+   PCL::|COMPILER::FN SLOT0| PCL::EARLY-CLASS-SLOTS
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::INCLUDES)|
+   PCL::READERS PCL::SYM COMMON-LISP::MULTIPLE-VALUE-CALL
+   PCL::SLOTD-CLASS-NAME PCL::PARSED PCL::|(BOUNDP SLOTS)|
+   PCL::|(WRITER FROM-DEFCLASS-P)| PCL::GF-NREQ
+   PCL::REMOVE-DIRECT-SUBCLASSES PCL::|(WRITER DFUN-STATE)|
+   PCL::EXTRACT-REQUIRED-PARAMETERS PCL::REQUIRED-PARAMETERS
+   PCL::CPD-SUPERS PCL::REAL-REMOVE-METHOD
+   PCL::*SGF-METHOD-CLASS-INDEX* PCL::*SGF-METHODS-INDEX*
+   PCL::OLD-SLOTD PCL::RECORD-CYCLE PCL::ACTUAL-SIZE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SOURCE)| PCL::GCL_PCL_CTYPES
+   PCL::INCLUDES PCL::FIX-SUPER PCL::INVALID-METHOD PCL::CCLOSUREP
+   PCL::MISS-LABEL PCL::NEW-SUPER PCL::GENERATING-LISP
+   PCL::INITIAL-VALUE COMMON-LISP::SINGLE-FLOAT-EPSILON
+   COMMON-LISP::SINGLE-FLOAT-NEGATIVE-EPSILON PCL::OLD-INTERN-P
+   PCL::|(BOUNDP PLIST)| ITERATE::ELEMENTS PCL::READER PCL::ACC-NAME
+   PCL::MEC-ALL-CLASSES S::C-SET-FUNCTION-DATA
+   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::SLOT-ACCESSOR-FUNCTION
+   PCL::WRAPPER-CLASS PCL::RENAME-PCL PCL::.SLOTS. PCL::ECD-METACLASS
+   PCL::REAL-GET-METHOD PCL::GCL_PCL_INIT PCL::FIND-FREE
+   PCL::CLASS-CAN-PRECEDE-LIST PCL::SET-ARG-INFO1
+   PCL::METHOD-FUNCTION-CLOSURE-GENERATOR PCL::|(BOUNDP TYPE)|
+   PCL::|(BOUNDP OBJECT)| PCL::CACHES-TO-ALLOCATE
+   PCL::|(WRITER PROTOTYPE)| COMMON-LISP::LIST-ALL-PACKAGES
+   PCL::PARSE-SPECIALIZERS
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION DEFSTRUCT-ACCESSOR-SYMBOL)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
+   COMMON-LISP::MAPCON PCL::NET-CODE-CONVERTER COMMON-LISP::FILE-STREAM
+   PCL::|(WRITER CAN-PRECEDE-LIST)| PCL::METH PCL::|(READER OPTIONS)|
+   PCL::|(READER METHODS)| S::*UINT PCL::DIRECT-DEFAULT-INITARGS
+   PCL::GCL_PCL_MACROS PCL::BINDING COMMON-LISP::CONSTANTP
+   COMMON-LISP::NIL PCL::|(WRITER SLOT-DEFINITION)|
+   PCL::|COMPILER::BINDING SLOT1|
+   PCL::FUNCALLABLE-INSTANCE-AVAILABLE-SIZE
+   PCL::FUNCALLABLE-INSTANCE-CLOSURE-SIZE COMMON-LISP::SETF
+   PCL::GCL_PCL_FIXUP PCL::|(BOUNDP CLASS)| PCL::CURRENT
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD)| PCL::EXCL
+   COMMON-LISP::WRITE-STRING PCL::FUNCALLABLE-STANDARD-CLASS-P
+   S::C-ADJARRAY-DISPLACED COMMON-LISP::MAKE-STRING-INPUT-STREAM
+   COMMON-LISP::MAKE-STRING-OUTPUT-STREAM PCL::GCL_PCL_COMPAT PCL::ZERO
+   PCL::.VALID-KEYS. COMMON-LISP::COPY-ALIST
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::DEF)|
+   PCL::INSTANCE-WRITE-INTERNAL PCL::|(WRITER LAMBDA-LIST)|
+   COMMON-LISP::GETF PCL::MAKE-EMF-CALL COMMON-LISP::CONSTANTLY
+   PCL::FIND-CLASS-CELL PCL::DEFINE-CACHED-READER
+   COMMON-LISP::MACROEXPAND-1 PCL::PARSE-SPECIALIZED-LAMBDA-LIST
+   PCL::GCL_PCL_VECTOR PCL::ORIG-ARGS COMMON-LISP::NSUBST
+   PCL::CLASS-SIMPLE-TYPEP-FN PCL::SPEC-ARGS
+   PCL::|(READER DIRECT-SUPERCLASSES)|
+   PCL::|(READER DIRECT-SUBCLASSES)| PCL::SET-METHODS
+   PCL::DFUN-ARG-SYMBOL-LIST PCL::NEW-METHODS
+   PCL::|__si::MAKE-CHECKING|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::INCLUDED)|
+   PCL::GCL_PCL_FIN PCL::.ARGS. PCL::|(WRITER FUNCTION)|
+   PCL::|(WRITER GENERIC-FUNCTION)| PCL::|(READER BOUNDP-FUNCTION)|
+   PCL::|COMPILER::BINDING SLOT0| PCL::MK-EARLY-CPL PCL::BIND-ARGS
+   PCL::GCL_PCL_CPL PCL::*WRITERS* COMMON-LISP::PUSH
+   PCL::EARLY-METHOD-STANDARD-ACCESSOR-P PCL::REST-ARGS PCL::OLD-LAYOUT
+   COMMON-LISP::STORAGE-CONDITION PCL::NOISYP
+   COMMON-LISP::*TERMINAL-IO* PCL::*READERS*
+   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::|(READER DIRECT-METHODS)| PCL::|(READER DIRECT-SLOTS)|
+   PCL::NEW-LAYOUT PCL::INITIAL-CACHE PCL::LAMBDA-LIST-P
+   PCL::STANDARD-WRITER-METHOD-SIMPLE-TYPEP-FN
+   PCL::BOOTSTRAP-SLOT-INDEX PCL::NOT-SIMPLE-P-CELL
+   PCL::GF-INFO-FAST-MF-P PCL::EARLY-CLASS-DEFINITION
+   PCL::METHOD-COMBINATION-OPTIONS S::C-OCOMPLEX-IMAG
+   PCL::|(READER METHOD-COMBINATION)|
+   PCL::|(READER INTERNAL-READER-FUNCTION)|
+   PCL::|(READER INTERNAL-WRITER-FUNCTION)| PCL::|(SETF OBJECT-PLIST)|
+   COMMON-LISP::MAPCAR PCL::META COMMON-LISP::ISQRT COMMON-LISP::CHAR
+   PCL::|(READER METHOD-CLASS)| PCL::OLD-POSITION
+   COMMON-LISP::DELETE-PACKAGE PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
+   PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES COMMON-LISP::LOGORC2
+   PCL::COLLECTED PCL::CAN-PRECEDE-LIST PCL::NLOCAL
+   COMMON-LISP::RENAME-PACKAGE S::C-SET-T-MADJUSTABLE PCL::CACHED-EMF-P
+   PCL::REAL-BODY COMMON-LISP::*PRINT-RIGHT-MARGIN*
+   PCL::TWO-CLASS-INDEX COMMON-LISP::EXP COMMON-LISP::MAPCAN
+   PCL::CALL-INITIALIZE-INSTANCE-SIMPLE PCL::|(READER FAST-FUNCTION)|
+   PCL::|(WRITER ALLOCATION)| PCL::|__si::MAKE-CONSTANT-VALUE|
+   PCL::MAKE-STD-WRITER-METHOD-FUNCTION PCL::METHOD-SPEC
+   PCL::PV-PARAMETERS PCL::FUNCALLABLE-INSTANCE-P PCL::FILTER
+   PCL::IMPLIED PCL::CACHED-VALID-P COMMON-LISP::MACHINE-TYPE
+   PCL::METHOD-FUNCTION-GET PCL::INSTANCE-BOUNDP-INTERNAL
+   COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::DEFUN
+   PCL::|(WRITER INITIAL-METHODS)|
+   PCL::EXPANDING-MAKE-INSTANCE-TOP-LEVEL COMMON-LISP::LOGORC1
+   PCL::|(BOUNDP NAME)| PCL::GET-SETF-FUNCTION-NAME
+   PCL::|(WRITER SLOT-NAME)| PCL::DESC COMMON-LISP::ASSOC
+   PCL::MAP-ALL-CLASSES PCL::STANDARD-CLASS-WRAPPER
+   PCL::CAR-ALL-CLASSES PCL::OPTIMIZE-INSTANCE-ACCESS
+   PCL::CACHED-INDEX-P PCL::FAST-METHOD PCL::.EMF. S::DEFDLFUN
+   PCL::FIELD-TYPE-SIMPLE-TYPEP-FN COMMON-LISP::DO*
+   COMMON-LISP::PATHNAME-VERSION COMMON-LISP::NSUBSTITUTE-IF-NOT
+   PCL::MAIN-METHOD PCL::SAUT-CLASS-EQ PCL::GCL_PCL_COMBIN
+   COMMON-LISP::SYMBOL PCL::SET-STRUCTURE-SVUC-METHOD PCL::ADJUST-CACHE
+   PCL::MISS-FN PCL::|__si::MAKE-INITIAL-DISPATCH|
+   PCL::|__si::MAKE-DISPATCH| PCL::|(READER FROM-DEFCLASS-P)|
+   COMMON-LISP::NINTERSECTION COMMON-LISP::REPLACE
+   COMMON-LISP::MAKE-METHOD PCL::GCL_PCL_WALK PCL::STANDARD-SVUC-METHOD
+   PCL::STANDARD-BOUNDP-METHOD-SIMPLE-TYPEP-FN
+   PCL::MAKE-INITIAL-DISPATCH PCL::|(READER DFUN-STATE)|
+   COMMON-LISP::TAGBODY COMMON-LISP::DEFMACRO COMMON-LISP::DEFCONSTANT
+   COMMON-LISP::CHAR-CODE PCL::DO-FILL
+   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::PORT-DNAME
+   PCL::COMPUTE-PV COMMON-LISP::PACKAGE-NAME PCL::ANALYZE-LAMBDA-LIST
+   PCL::|(WRITER INITFORM)| COMMON-LISP::LOGCOUNT PCL::TYPE-CLASS
+   PCL::|__si::MAKE-PV-TABLE| PCL::*REBOUND-EFFECTIVE-METHOD-GENSYMS*
+   PCL::SLOT-ACCESSOR-STD-P PCL::DESTRUCTURE-INTERNAL
+   PCL::|(WRITER WRITERS)| S::MATRIX PCL::OBSOLETE-INSTANCE-TRAP
+   COMMON-LISP::FUNCALL PCL::INITARG PCL::SLOT-CLASS
+   COMMON-LISP::DECLAIM PCL::FAST-READER-METHOD
+   PCL::|(WRITER INITFUNCTION)| PCL::|(WRITER WRITER-FUNCTION)|
+   PCL::REASONS PCL::W-TAIL PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION
+   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION
+   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::*UMI-REORDER*
+   COMMON-LISP::NSUBST-IF COMMON-LISP::DEFTYPE PCL::INSTANCE-WRITE
+   PCL::FGEN PCL::|(READER PROTOTYPE)| PCL::CAM-METHODS PCL::SAUT-CLASS
+   PCL::|__si::MAKE-CACHE| PCL::INVOKE-METHOD-CALL1 PCL::METHOD-LAMBDA
+   PCL::|(WRITER ARGUMENTS-LAMBDA-LIST)|
+   PCL::|(READER CAN-PRECEDE-LIST)| PCL::*EQL-SPECIALIZER-METHODS*
+   PCL::RETURN-FUNCTION-P PCL::GF-CLASS-P PCL::TRUTH
+   PCL::*PUT-IMPL-BINARIES-IN-IMPL-DIRECTORY-P* PCL::PV-ENV
+   PCL::SWAP-WRAPPERS-AND-SLOTS PCL::OPTIMIZE-WRITER
+   PCL::|PCL::CLASS-PRECEDENCE-DESCRIPTION class predicate|
+   PCL::|PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate|
+   S::C-RATIO-NUM PCL::STANDARD-DIRECT-SLOT-DEFINITION-WRAPPER
+   PCL::|(READER SLOT-DEFINITION)| COMMON-LISP::ECHO-STREAM
+   PCL::LINE-PRIMARY-LOCATION PCL::FOR-CACHE-P PCL::ADDED-SLOTS
+   PCL::EARLY-COLLECT-SLOTS COMMON-LISP::NTHCDR
+   PCL::INTERNAL-WRITER-FUNCTION S::C-SET-PACKAGE-SHADOWINGS
+   PCL::PARSE-METHOD-OR-SPEC PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL
+   PCL::REASON PCL::CVECTOR-TYPE PCL::FINALLY PCL::GCL_PCL_PKG
+   PCL::|(READER LAMBDA-LIST)| COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
+   PCL::|__si::MAKE-STD-INSTANCE| S::*UCHAR PCL::GENS PCL::OFFSET
+   PCL::SPECL2 PCL::STANDARD-CLASS-SIMPLE-TYPEP-FN
+   PCL::STANDARD-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::NEW-INTERN-P
+   COMMON-LISP::WITH-STANDARD-IO-SYNTAX PCL::VAXL-LOW
+   PCL::|(READER FUNCTION)| PCL::|(READER GENERIC-FUNCTION)|
+   PCL::DIRECT-DEFAULT-INITARGS-P
+   PCL::%ALLOCATE-STATIC-SLOT-STORAGE--CLASS
+   PCL::|(WRITER DEFSTRUCT-FORM)| PCL::FORCEP
+   PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE COMMON-LISP::SYMBOLP
+   COMMON-LISP::ACONS PCL::OPTIMIZE-READER PCL::GET-DISPATCH-FUNCTION
+   PCL::.NEXT-METHODS. PCL::LEGAL-SPECIALIZERS-P
+   PCL::|(WRITER PRETTY-ARGLIST)| COMMON-LISP::*READ-EVAL*
+   PCL::ONE-INDEX-DFUN-INFO-P PCL::.ARG4.
+   COMMON-LISP::LONG-FLOAT-EPSILON
+   COMMON-LISP::LONG-FLOAT-NEGATIVE-EPSILON PCL::CLOSURE-VARIABLES
+   PCL::BOOLEAN-VALUES-P PCL::|(SETF METHOD-GENERIC-FUNCTION)|
+   PCL::MAKE-EMF-CACHE
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL
+   PCL::.ARG3. PCL::CACHING-LIMIT-FN SYSTEM::FUNCALLABLE-STD-INSTANCE
+   PCL::SLOT-NAME-LISTS-FROM-SLOTS PCL::LEGAL PCL::.ARG2.
+   PCL::|(WRITER IDENTITY-WITH-ONE-ARGUMENT)|
+   COMMON-LISP::DESTRUCTURING-BIND COMMON-LISP::ACOSH
+   S::C-SET-PACKAGE-NICKNAMES PCL::OPTIMIZE-SLOT-BOUNDP
+   PCL::|(CALL REAL-ENSURE-GF-USING-CLASS--NULL)| PCL::GCL_PCL_FSC
+   PCL::GET-MAKE-INSTANCE-FUNCTIONS PCL::CANONICALIZE-DEFCLASS-OPTION
+   PCL::CANONICALIZE-SLOT-SPECIFICATION
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1 PCL::.ARG1.
+   PCL::|(WRITER SPECIALIZERS)| PCL::SETFBOUNDP
+   PCL::|(WRITER DECLARATIONS)| PCL::NEW-METATYPE
+   PCL::CHECK-DECLARATION PCL::INITIALIZE-INFO-CACHED-NEW-KEYS
+   PCL::INITIALIZE-INFO-NEW-KEYS PCL::REAL-ADD-METHOD PCL::.ARG0.
+   COMMON-LISP::SUBSETP COMMON-LISP::NUMBERP COMMON-LISP::RESTART-NAME
+   PCL::REDIRECT-EARLY-FUNCTION-INTERNAL S::C-SET-SYMBOL-PLIST
+   S::C-RATIO-DEN PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION-WRAPPER
+   PCL::|(READER ALLOCATION)| COMMON-LISP::SUBST PCL::DEFAULT-METHOD
+   SYSTEM::MEMQ COMMON-LISP::DOTIMES PCL::TEMP PCL::UNORDERED-METHODS
+   PCL::SLOT-OBJECT COMMON-LISP::BOOLE-C1
+   PCL::|(CALL REAL-MAKE-METHOD-INITARGS-FORM)|
+   COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS PCL::DEFINITION-NAME
+   SYSTEM::C-FLOAT-== PCL::METHOD-FUNCTION-RETURNING-NIL
+   PCL::DESIRABILITY PCL::|PCL::TWO-CLASS class predicate|
+   PCL::PARSE-KEYWORD-ARGUMENT
+   PCL::|(WRITER INCOMPATIBLE-SUPERCLASS-LIST)| S::C-STREAM-OBJECT1
+   PCL::|(READER INITIAL-METHODS)| PCL::DESCEND
+   PCL::STANDARD-DIRECT-SLOT-DEFINITION-SIMPLE-TYPEP-FN
+   PCL::|(READER SLOT-NAME)| COMMON-LISP::LET* S::C-T-MOFFSET
+   PCL::CANONICAL-SLOTS PCL::*RAISE-METATYPES-TO-CLASS-P*
+   PCL::TWO-CLASS-WRAPPER1 PCL::LINE-WRAPPERS PCL::GET-FUNCTION1
+   PCL::STANDARD-GENERIC-FUNCTION-WRAPPER PCL::.PLIST-TAIL.
+   PCL::FUNCTION-PRETTY-ARGLIST PCL::FUNCTION-ARGLIST
+   COMMON-LISP::READ-FROM-STRING PCL::WRAPPER-STATE
+   PCL::CHECK-ARGUMENT-PRECEDENCE-ORDER
+   PCL::|(CALL REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION)|
+   PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
+   PCL::GET-ACCESSOR-METHOD-FUNCTION PCL::ONE-INDEX-ACCESSOR-TYPE
+   PCL::NOT-AN-EQL-SPECIALIZER
+   PCL::GENERATE-DISCRIMINATION-NET-INTERNAL PCL::STRINGS
+   COMMON-LISP::SUBST-IF-NOT COMMON-LISP::STRING
+   COMMON-LISP::*PRINT-GENSYM* PCL::REL-8 PCL::NEW-POSITION
+   S::C-STREAM-OBJECT0 PCL::CACHE-LINE-SIZE PCL::NAME-DSLOTDS-ALIST
+   PCL::DECLS PCL::GET-DECLARATION PCL::WALKED-LAMBDA
+   PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD PCL::STANDARD-BOUNDP-METHOD
+   PCL::STANDARD-METHOD-COMBINATION PCL::FEATURE COMMON-LISP::NCONC
+   S::C-BIGNUM-MPZ_T PCL::|FAST-METHOD-CALL SLOT3|
+   PCL::EXPANDING-MAKE-INSTANCE PCL::GET-SECONDARY-DISPATCH-FUNCTION
+   PCL::TWO-CLASS-WRAPPER0 PCL::INSTANCE-READ PCL::SAUT-NOT
+   PCL::|(WRITER DOCUMENTATION)| PCL::|(WRITER LOCATION)|
+   COMMON-LISP::COMPILATION-SPEED PCL::METHOD-COMBINATION-P
+   PCL::OWRAPPER PCL::NWRAPPER PCL::CWRAPPER PCL::LWRAPPER
+   PCL::|(READER INITFORM)| PCL::UNPARSE-SPECIALIZERS PCL::TI-LOW
+   PCL::|(WRITER ACCESSOR-FLAGS)| PCL::.NEXT-METHOD-CALL. PCL::FROM-LOC
+   PCL::PPSYMS PCL::*NEXT-METHODS* COMMON-LISP::MAKE-ECHO-STREAM
+   PCL::|(READER WRITERS)| PCL::|(WRITER CLASS-PRECEDENCE-LIST)|
+   PCL::OTHER-INITARGS PCL::DELQ PCL::EARLY-CLASS-NAME
+   COMMON-LISP::NUMBER PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P
+   COMMON-LISP::ERROR PCL::TWO-CLASS-ACCESSOR-TYPE PCL::.METHOD.
+   PCL::GF-VAR PCL::INITIALIZE-INFO-CACHED-CONSTANTS
+   PCL::INITIALIZE-INFO-CONSTANTS PCL::|FAST-METHOD-CALL SLOT2|
+   PCL::INITIALIZE-INTERNAL-SLOT-FUNCTIONS COMMON-LISP::MAKE-STRING
+   COMMON-LISP::BASE-STRING COMMON-LISP::RESTART-BIND
+   PCL::METHOD-FUNCTION-PV-TABLE PCL::SV PCL::|(READER INITFUNCTION)|
+   PCL::|(READER WRITER-FUNCTION)| PCL::PV COMMON-LISP::WRITE-BYTE
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION PCL::NV PCL::OPERATION
+   PCL::INVALIDP PCL::NF COMMON-LISP::DEBUG PCL::MF
+   PCL::COMPUTE-CACHE-PARAMETERS PCL::FSPEC
+   PCL::.LONG-METHOD-COMBINATION-FUNCTION. PCL::INSTANCE-READ-INTERNAL
+   PCL::|(READER ARGUMENTS-LAMBDA-LIST)| PCL::|(WRITER READERS)|
+   COMMON-LISP::FOURTH COMMON-LISP::IF PCL::DEFCLASS-FORM PCL::GF
+   PCL::SDFUN PCL::NEXT-CPD PCL::*NKEYS-LIMIT*
+   PCL::BOOTSTRAP-INITIALIZE-CLASS PCL::METHOD-KEY-KEYWORDS
+   COMMON-LISP::*RANDOM-STATE*
+   PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN
+   PCL::|(WRITER PREDICATE-NAME)| WALKER::VARIABLE-SPECIAL-P
+   S::C-SET-OCOMPLEX-IMAG PCL::DONT-CREATE-P
+   PCL::|FAST-METHOD-CALL SLOT1|
+   PCL::|(SETF CLASS-DEFSTRUCT-CONSTRUCTOR)| COMMON-LISP::NULL
+   PCL::METHOD-COMBINATION-SUPPLIED-P COMMON-LISP::CHAR-GREATERP
+   PCL::|(WRITER READER-FUNCTION)| COMMON-LISP::REMF
+   PCL::CLASS-CAN-PRECEDE-P PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION
+   PCL::PV-WRAPPERS PCL::OEMF COMMON-LISP::ASSOC-IF-NOT
+   PCL::GF-LAMBDA-LIST PCL::NEMF PCL::NO-FMF-P
+   COMMON-LISP::*BREAK-ON-SIGNALS* PCL::INITIALIZE-INFO-KEY PCL::CTPS
+   PCL::CELL PCL::BUILT-IN-INSTANCE PCL::MAKE-PV-TYPE-DECLARATION
+   PCL::DFUN-WRAPPERS PCL::UPDATE-C-A-M-GF-INFO COMMON-LISP::MEMBER
+   PCL::UPDATE-ALL-PV-TABLE-CACHES PCL::GF-LIST PCL::OTHER
+   S::C-SET-PACKAGE-INTERNAL_SIZE S::C-SET-PACKAGE-EXTERNAL_SIZE
+   PCL::ONE-CLASS-INDEX PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
+   PCL::STANDARD-METHOD-SIMPLE-TYPEP-FN
+   PCL::STANDARD-READER-METHOD-SIMPLE-TYPEP-FN
+   PCL::STANDARD-GENERIC-FUNCTION-SIMPLE-TYPEP-FN
+   PCL::STANDARD-METHOD-COMBINATION-SIMPLE-TYPEP-FN
+   PCL::PARSE-DEFMETHOD COMMON-LISP::LOGBITP PCL::ORIGINAL-DEFINITION
+   PCL::|FAST-METHOD-CALL SLOT0| PCL::WAS-VALID-P
+   COMMON-LISP::MAKE-DISPATCH-MACRO-CHARACTER PCL::*THE-CLASS-T*
+   COMMON-LISP::*PRINT-LENGTH* PCL::QUALS PCL::UNPARSED PCL::MAKE-POP
+   PCL::*LONG-METHOD-COMBINATION-FUNCTIONS*
+   PCL::|(READER DEFSTRUCT-FORM)| COMMON-LISP::INTEGER-LENGTH
+   PCL::FIND-WRAPPER PCL::COMPUTE-MCASE-PARAMETERS PCL::P-TAIL
+   COMMON-LISP::STRINGP PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::|(READER PRETTY-ARGLIST)| COMMON-LISP::LDIFF
+   PCL::*BUILT-IN-WRAPPER-SYMBOLS* PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P
+   PCL::PCL-CLASS-SIMPLE-TYPEP-FN PCL::SAUT-EQL PCL::TO-LOC
+   PCL::|(SETF CLASS-INITIALIZE-INFO)| COMMON-LISP::REALP
+   PCL::GCL_PCL_CACHE COMMON-LISP::CDDDDR PCL::MAKE-N-N
+   COMMON-LISP::CADDDR PCL::N-SIZE COMMON-LISP::PUSHNEW
+   COMMON-LISP::SOFTWARE-TYPE COMMON-LISP::DELETE-IF PCL::LUCID
+   PCL::FN-NAME 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::MAKE-METHOD-INITARGS-FORM-INTERNAL1
+   PCL::MAKE-STD-READER-METHOD-FUNCTION PCL::CVT PCL::INITIAL-DFUN-INFO
+   PCL::COUNT-ALL-DFUNS PCL::|PCL::CHECKING class predicate|
+   PCL::|PCL::DFUN-INFO class predicate|
+   PCL::|(READER IDENTITY-WITH-ONE-ARGUMENT)| COMMON-LISP::ARRAY
+   PCL::SPECL-APPLICABLE-P PCL::COMPUTE-CLASS-SLOTS PCL::GF-NAME
+   COMMON-LISP::*PRINT-CIRCLE* PCL::|(READER SPECIALIZERS)|
+   PCL::SLOT-NAME-LIST PCL::SLOTS-ALIST PCL::KEY
+   PCL::|(READER DECLARATIONS)| COMMON-LISP::CDDDAR
+   COMMON-LISP::SHORT-SITE-NAME PCL::METHOD-FUNCTION-LAMBDA
+   PCL::STANDARD-ACCESSOR-METHOD-SIMPLE-TYPEP-FN COMMON-LISP::CADDAR
+   COMMON-LISP::*PRINT-ESCAPE* COMMON-LISP::*PRINT-BASE*
+   COMMON-LISP::*PRINT-CASE* COMMON-LISP::OPTIMIZE
+   PCL::|COMPILER::FN class predicate| PCL::MAX-LOCATION PCL::PROTO
+   PCL::UPDATE-FN PCL::%INVALID-QUALIFIERS PCL::FLUSH-CACHE-TRAP
+   S::+FL+ PCL::UPDATE-ALL-C-A-M-GF-INFO COMMON-LISP::ABORT
+   PCL::|(READER INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::STANDARD-OBJECT-SIMPLE-TYPEP-FN COMMON-LISP::PATHNAME-MATCH-P
+   WALKER::VARIABLE-GLOBALLY-SPECIAL-P S::C-SET-HASHTABLE-PAD5
+   PCL::MAKE-WRITER-METHOD-FUNCTION
+   PCL::CLASS-PROTOTYPE-SPECIALIZER-SIMPLE-TYPEP-FN PCL::SLOT-VAR
+   PCL::MAKE-BUILT-IN-WRAPPER-OF-BODY PCL::CHOICES
+   COMMON-LISP::BOOLE-XOR PCL::GFS COMMON-LISP::&WHOLE
+   PCL::INITIAL-DISPATCH-DFUN-INFO COMMON-LISP::LOCALLY PCL::SAUT-AND
+   PCL::*BUILT-IN-TYPEP-COST* PCL::DESTRUCTURE
+   PCL::TRY-ONE-FILL-FROM-LINE PCL::SLOT+INDEX
+   COMMON-LISP::GET-DECODED-TIME PCL::SUPERCLASS-NAMES
+   PCL::LOAD-TRUENAME S::*OBJECT PCL::|(SETF CLASS-SLOT-VALUE)|
+   COMMON-LISP::ATOM PCL::.GF-ARGS. S::C-SET-HASHTABLE-PAD4 PCL::READP
+   PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
+   PCL::INITIALIZE-INFO-MAKE-INSTANCE-FUNCTION-SYMBOL
+   COMMON-LISP::CDADDR PCL::CLASS-INITIALIZE-INFO PCL::AUX
+   PCL::.CM-ARGS. PCL::OLD-CLASS-SLOTS PCL::|(READER DOCUMENTATION)|
+   PCL::|(READER LOCATION)| COMMON-LISP::CAADDR COMMON-LISP::SUBST-IF
+   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION
+   PCL::|(READER ACCESSOR-FLAGS)| PCL::UNINTERNED-NAME
+   PCL::|(READER CLASS-PRECEDENCE-LIST)|
+   COMMON-LISP::TYPE-ERROR-EXPECTED-TYPE COMMON-LISP::COUNT-IF-NOT
+   PCL::RASSQ PCL::LOCATION-WRAPPERS PCL::DLAP-LAMBDA-LIST
+   COMMON-LISP::CDADAR PCL::FUNCTION-SPECIFIER PCL::UPDATE-CPL
+   PCL::CHECKING-P PCL::CHECKING- COMMON-LISP::DEFSETF
+   COMMON-LISP::CAADAR COMMON-LISP::FORMATTER S::C-SET-HASHTABLE-PAD3
+   COMMON-LISP::SXHASH PCL::ASSQ PCL::SPEC-LL PCL::OPTIMIZE-SLOT-VALUE
+   PCL::INDENTATION PCL::DEFAULT COMMON-LISP::BOOLE-EQV
+   PCL::PARSE-QUALIFIER-PATTERN PCL::INITIALIZE-INTERNAL-SLOT-GFS
+   PCL::.PV-CELL. PCL::.METHOD-ARGS. COMMON-LISP::PROGV
+   PCL::POP-INITARGS PCL::INTERNAL-READER-FUNCTION PCL::SLOTD-TYPE
+   COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::CERROR
+   COMMON-LISP::STRING<= COMMON-LISP::STRING>= COMMON-LISP::STRING/=
+   PCL::FIELD-TYPE PCL::ADD/REMOVE PCL::|SYSTEM:S-DATA SLOT17| PCL::NEW
+   PCL::|(READER READERS)| COMMON-LISP::SIMPLE-BIT-VECTOR PCL::MAKE-CPD
+   PCL::CACHE-LOCK-COUNT COMMON-LISP::BOOLE-NOR
+   PCL::SET-FUNCTION-NAME-1 PCL::|(READER PREDICATE-NAME)|
+   COMMON-LISP::COMPILE-FILE-PATHNAME S::SET-ARRAY-DIMS
+   S::C-SET-HASHTABLE-PAD2 PCL::OPTIMIZE-GF-CALL COMMON-LISP::SEARCH
+   PCL::|COMPILER::BINDING class predicate|
+   PCL::|(READER READER-FUNCTION)| COMMON-LISP::COPY-SYMBOL
+   PCL::COMPARE-CLASSES-FUNCTION PCL::ARGUMENT-PRECEDENCE-ORDER
+   PCL::|SYSTEM:S-DATA SLOT16| PCL::.METH-LIST.
+   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::SMC-WRAPPER
+   S::C-SET-HASHTABLE-PAD1 PCL::OPTIMIZE-GENERIC-FUNCTION-CALL
+   COMMON-LISP::BOOLE-IOR COMMON-LISP::RATIO
+   PCL::COMPILE-LAMBDA-DEFERRED PCL::SLOT-BOUNDP-USING-CLASS-DFUN
+   PCL::KEYWORD-PARAMETERS
+   PCL::|(COMBINED-METHOD ENSURE-CLASS-USING-CLASS)|
+   PCL::|(COMBINED-METHOD CHANGE-CLASS)|
+   PCL::|(COMBINED-METHOD ENSURE-GENERIC-FUNCTION-USING-CLASS)|
+   COMMON-LISP::PROGN PCL::*CACHE-LOOKUP-COST*
+   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
+   S::C-SET-SYMBOL-HPACK PCL::DEFSYSTEM COMMON-LISP::RPLACD
+   PCL::SHOW-FREE-CACHE-VECTORS PCL::%STD-INSTANCE-SLOTS
+   COMMON-LISP::DIVISION-BY-ZERO COMMON-LISP::&BODY
+   PCL::|SYSTEM:S-DATA SLOT15| PCL::FUNCTION-APPLY
+   COMMON-LISP::CHAR-NOT-GREATERP PCL::CLASS+INITARGS S::C-FUNCTION-VV
+   PCL::LEGAL-LAMBDA-LIST-P S::C-SET-SYMBOL-HASH PCL::EARLY
+   PCL::COMPLICATED-INSTANCE-CREATION-METHOD PCL::DECLARATION-NAME
+   PCL::ARGUMENTS-LAMBDA-LIST PCL::OLD-WRAPPER COMMON-LISP::NRECONC
+   COMMON-LISP::ASINH COMMON-LISP::ROW-MAJOR-AREF
+   PCL::ADD-BOUNDP-METHOD PCL::LINE-MATCHES-WRAPPERS-P
+   PCL::LEGAL-QUALIFIERS-P PCL::*EARLY-CLASS-SLOTS*
+   PCL::*EARLY-CLASS-DEFINITIONS* PCL::VALUE-FORM
+   PCL::|SYSTEM:S-DATA SLOT14| PCL::FREE-CACHE-P
+   PCL::FIND-STANDARD-II-METHOD PCL::*IN-OBSOLETE-INSTANCE-TRAP*
+   COMMON-LISP::CDDDR PCL::BIND-SIMPLE-LEXICAL-METHOD-MACROS
+   PCL::OPTIMIZE-ACCESSOR-CALL COMMON-LISP::MACROLET
+   PCL::*CLASS-EQ-SPECIALIZER-METHODS* PCL::ONE-CLASS-WRAPPER0
+   COMMON-LISP::GET-INTERNAL-RUN-TIME
+   COMMON-LISP::GET-INTERNAL-REAL-TIME PCL::EMIT-GREATER-THAN-1-DLAP
+   PCL::.CALL-METHOD-LIST. COMMON-LISP::EQUAL COMMON-LISP::NUMERATOR
+   PCL::|(COMBINED-METHOD SHARED-INITIALIZE)|
+   PCL::INITIALIZE-INFO-CACHED-RI-VALID-P
+   PCL::INITIALIZE-INFO-CACHED-VALID-P PCL::INITIALIZE-INFO-RI-VALID-P
+   PCL::INITIALIZE-INFO-VALID-P S::C-SET-SYMBOL-STYPE COMMON-LISP::THE
+   PCL::NLAYOUT PCL::OLAYOUT PCL::CACHE-SIZE
+   PCL::|SYSTEM:S-DATA SLOT13| PCL::INITIAL-DISPATCH-P
+   PCL::REAL-ADD-NAMED-METHOD PCL::MAKE-INSTANCE-1
+   PCL::ONE-CLASS-ACCESSOR-TYPE PCL::GENERATOR PCL::PARSE
+   COMMON-LISP::CDDAR WALKER::VARIABLE-LEXICAL-P
+   PCL::CLASS-PRECEDENCE-DESCRIPTION COMMON-LISP::MOST-POSITIVE-FIXNUM
+   PCL::KEYWORDS PCL::SLOT-NAME-FORM PCL::UNENCAPSULATED-FDEFINITION
+   PCL::APPLICABLE-P S::C-CFDATA-START
+   COMMON-LISP::MOST-POSITIVE-SHORT-FLOAT
+   COMMON-LISP::MOST-POSITIVE-SINGLE-FLOAT
+   COMMON-LISP::MOST-POSITIVE-DOUBLE-FLOAT
+   COMMON-LISP::MOST-POSITIVE-LONG-FLOAT PCL::SLOT-SYMBOL
+   PCL::|PCL::EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::GENSYM-VAR PCL::PREDICATE-NAME PCL::|SYSTEM:S-DATA SLOT12|
+   PCL::*LOCAL-CACHE-FUNCTIONS* PCL::ARGUMENTS-OPTION
+   PCL::SORT-APPLICABLE-METHODS COMMON-LISP::EVAL PCL::.FREE.
+   PCL::CLASSP COMMON-LISP::HOST-NAMESTRING COMMON-LISP::NSUBSTITUTE-IF
+   PCL::*NEW-CLASS* PCL::MAKE-WRAPPER PCL::DECLARE-STRUCTURE
+   COMMON-LISP::PSETQ PCL::USERS PCL::BOOTSTRAP-META-BRAID
+   COMMON-LISP::EQUALP PCL::STATE PCL::INITIAL-LOCK-COUNT
+   S::C-SET-SYMBOL-NAME PCL::BOOTSTRAP-ACCESSOR-DEFINITION
+   COMMON-LISP::SET PCL::INVALIDATE-WRAPPER COMMON-LISP::BOOLE-CLR
+   PCL::SLOT-BOUNDP-NORMAL S::C-CFDATA-DLIST PCL::%STD-INSTANCE-WRAPPER
+   PCL::|SYSTEM:S-DATA SLOT11| PCL::DEFAULT-TEST-CONVERTER
+   PCL::ALLOCATED PCL::NET PCL::SF-KEY COMMON-LISP::CATCH
+   PCL::EFFECTIVE-METHOD-LAMBDA COMMON-LISP::BYTE-POSITION
+   COMMON-LISP::LET PCL::INITIALIZE-INSTANCE-SIMPLE
+   PCL::DEFAULT-METHOD-FUNCTION COMMON-LISP::FILE-WRITE-DATE
+   PCL::METHOD-CALL- COMMON-LISP::SCHAR PCL::OLD-STD-P COMMON-LISP::GET
+   PCL::ADDED PCL::PCL-DESCRIBE SYSTEM::PACKAGE-INTERNAL
+   SYSTEM::PACKAGE-EXTERNAL PCL::OPTIMIZE-SET-SLOT-VALUE
+   PCL::CANONICAL-SLOT-NAME PCL::*OPTIMIZE-SPEED*
+   PCL::FUNCALLABLE-INSTANCE-CLOSURE-SIZE1 PCL::FAST-WRITER-METHOD
+   PCL::RCPL PCL::COMBIN PCL::CAM-STD-P COMMON-LISP::ACOS
+   PCL::REQUIREDS PCL::COPY-CACHING PCL::MCPL PCL::EMIT-BOUNDP-CHECK
+   COMMON-LISP::GET-OUTPUT-STREAM-STRING PCL::|SYSTEM:S-DATA SLOT10|
+   PCL::INITIAL-DISPATCH COMMON-LISP::BOOLE-AND
+   COMMON-LISP::NSET-DIFFERENCE PCL::OCNV PCL::SET-STANDARD-SVUC-METHOD
+   PCL::TYPE-MODIFIER COMMON-LISP::WRITE-LINE
+   PCL::FIND-CLASS-CELL-MAKE-INSTANCE-FUNCTION-KEYS
+   COMMON-LISP::PACKAGE PCL::*DEFGENERIC-TIMES*
+   PCL::|ONE-INDEX-DFUN-INFO SLOT2| PCL::GF-INFO-STATIC-C-A-M-EMF
+   PCL::HP-LOW PCL::ARG-INFO-P PCL::TABLE+PV-OFFSET-LIST
+   PCL::REAL-MAKE-METHOD-INITARGS-FORM PCL::SPECL-POSSIBLY-APPLICABLE-P
+   COMMON-LISP::PRINT-NOT-READABLE-OBJECT PCL::RES COMMON-LISP::ATANH
+   PCL::CONSTANT-CONVERTER PCL::TTAIL
+   PCL::MAKE-PV-TABLE-TYPE-DECLARATION S::*CHAR PCL::LDIR
+   PCL::TO-CACHE-VECTOR S::C-SET-SYMBOL-SFDEF S::C-SET-SYMBOL-GFDEF
+   S::C-SET-SYMBOL-MFLAG COMMON-LISP::PSETF
+   COMMON-LISP::SIMPLE-BIT-VECTOR-P PCL::RESET-INITIALIZE-INFO
+   PCL::ADD-CLASS-LIST PCL::PROCLAIM-DEFGENERIC COMMON-LISP::FLOATP
+   COMMON-LISP::BOOLE-SET COMMON-LISP::INVOKE-RESTART-INTERACTIVELY
+   PCL::INVOKE-EMF PCL::ESETF PCL::UPDATE-SLOTS-IN-PV
+   S::C-SET-SYMBOL-DBIND PCL::NEXT-WRAPPER-CACHE-NUMBER-INDEX
+   COMMON-LISP::PATHNAME COMMON-LISP::PROG2 S::C-SET-CFDATA-START
+   PCL::INITIAL-DISPATCH-CACHE PCL::DISCARDED COMMON-LISP::PROG1
+   PCL::MAKE-TRANSFORM PCL::PARAM
+   PCL::FORWARD-REFERENCED-CLASS-SIMPLE-TYPEP-FN PCL::VALID-P
+   PCL::MAKE-CALL-METHODS COMMON-LISP::PROBE-FILE COMMON-LISP::CDADR
+   COMMON-LISP::MAKE-BROADCAST-STREAM
+   PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS COMMON-LISP::LOAD-TIME-VALUE
+   COMMON-LISP::FIND-SYMBOL COMMON-LISP::PRINT PCL::REL-7-2
+   PCL::MAKE-DISPATCH-LAMBDA PCL::TRUE PCL::EMIT-CACHING
+   PCL::INTERNAL-READER-METHOD COMMON-LISP::HASH-TABLE-TEST
+   PCL::COPY-DISPATCH S::C-SET-CFDATA-DLIST PCL::GET-METHOD-FUNCTION
+   PCL::|PCL::STRUCTURE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
+   COMMON-LISP::PACKAGE-USE-LIST COMMON-LISP::PACKAGE-USED-BY-LIST
+   PCL::SLOTS-INIT-P COMMON-LISP::READ-PRESERVING-WHITESPACE
+   COMMON-LISP::DRIBBLE PCL::INVALID-ARGUMENTS-FORM
+   PCL::*DEFAULT-PATHNAME-EXTENSIONS* PCL::CORAL-LOW COMMON-LISP::CDAAR
+   PCL::*CHECK-CACHE-P* PCL::*EMPTY-CACHE* PCL::LOCATION
+   PCL::DEFINITION-SOURCE-MIXIN-SIMPLE-TYPEP-FN PCL::SUBS
+   S::C-SET-T-MOFFSET COMMON-LISP::ARRAYP COMMON-LISP::PROG*
+   PCL::LEGALP COMMON-LISP::WRITE COMMON-LISP::*STANDARD-OUTPUT*
+   PCL::CLASS2 COMMON-LISP::INLINE PCL::GCL_PCL_DLISP2
+   PCL::*FREE-HASH-TABLES* PCL::DEFAULT-CONSTANT-CONVERTER
+   PCL::CLASS-PREDICATE-NAME PCL::SYS-PROCLAIM
+   COMMON-LISP::CELL-ERROR-NAME PCL::EMIT-TWO-CLASS-WRITER
+   COMMON-LISP::DECLARATION PCL::*EARLY-GENERIC-FUNCTIONS*
+   PCL::PRECOMPUTE-P PCL::STD-P PCL::MAKE-TYPE-PREDICATE
+   PCL::CAPITALIZE-WORDS PCL::GET-WRAPPER PCL::SET-WRAPPER
+   PCL::NEW-WRAPPER S::C-SET-BIGNUM-MPZ_T
+   PCL::WITH-MAKE-INSTANCE-FUNCTION-VALID-P-CHECK PCL::DECL
+   PCL::GET-BUILT-IN-CLASS-SYMBOL PCL::GET-BUILT-IN-WRAPPER-SYMBOL
+   PCL::FGEN-SYSTEM PCL::NEQ COMMON-LISP::FORCE-OUTPUT
+   COMMON-LISP::LOGAND PCL::FN-VARIABLE PCL::STRUCTURE-SLOT-BOUNDP
+   PCL::*STANDARD-SLOT-VALUE-USING-CLASS-METHOD*
+   PCL::*STANDARD-SETF-SLOT-VALUE-USING-CLASS-METHOD*
+   PCL::*STANDARD-SLOT-BOUNDP-USING-CLASS-METHOD* PCL::PRINT-ONLY
+   PCL::OPERATOR PCL::*SYSTEM-DIRECTORY*
+   PCL::|PCL::FUNCALLABLE-STANDARD-OBJECT class predicate|
+   ITERATE::ITERATE PCL::EMIT-TWO-CLASS-READER
+   PCL::FUNCTION-RETURNING-T PCL::GCL_PCL_PRECOM2
+   PCL::|PCL::METHOD-CALL class predicate| COMMON-LISP::REVAPPEND
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-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
+   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))|
+   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 RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
+   PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|
+   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
+   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (CLASS))|
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
+   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 SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
+   PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
+   PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
+   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-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 CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
+   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::ONE-INDEX-DFUN-INFO- COMMON-LISP::BOOLE-2 PCL::READ/WRITE
+   PCL::CANDIDATES PCL::FINAL-ACCESSOR-DFUN-TYPE COMMON-LISP::VARIABLE
+   PCL::*STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD*
+   PCL::*STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD*
+   PCL::*STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD*
+   ITERATE::WITH-GATHERING PCL::GCL_PCL_PRECOM1
+   PCL::INVALID-ARGUMENTS-P PCL::ST PCL::ARG-INFO-NUMBER-OPTIONAL
+   PCL::SEP PCL::MAKE-BUILT-IN-CLASS-TREE COMMON-LISP::PRINC
+   PCL::MAKE-PV-TABLE-INTERNAL COMMON-LISP::FILE-NAMESTRING
+   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
+   PCL::|(FAST-METHOD 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 REINITIALIZE-INSTANCE (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|
+   PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|
+   PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|
+   PCL::|(FAST-METHOD NO-NEXT-METHOD (STANDARD-GENERIC-FUNCTION STANDARD-METHOD))|
+   PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD NO-PRIMARY-METHOD (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+   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 (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+   COMMON-LISP::SPECIAL-OPERATOR-P PCL::PREDICATE S::C-FIXNUM-FLOAT-==
+   PCL::MT PCL::DEFAULT-METHOD-ONLY-P S::C-SET-STREAM-FLAGS
+   COMMON-LISP::DECF COMMON-LISP::MAKE-RANDOM-STATE PCL::SAUT-PROTOTYPE
+   PCL::IT PCL::*STRUCTURE-TABLE* PCL::*BUILT-IN-CLASSES* PCL::FT
+   PCL::CT PCL::NUMBER-OF-REQUIREDS COMMON-LISP::ED PCL::EXCL-LOW
+   COMMON-LISP::BOOLE-1 PCL::FILL-CACHE-P PCL::*EARLY-FUNCTIONS*
+   PCL::|PCL::METAOBJECT class predicate| PCL::|TWO-CLASS SLOT4|
+   COMMON-LISP::BOOLE-NAND PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL
+   S::C-SET-ARRAY-OFFSET PCL::*BUILT-IN-CLASS-SYMBOLS* S::C-SET-T-MRANK
+   PCL::FROM-LOCATION PCL::*PVS* PCL::VALUE PCL::QUAL
+   PCL::MAKE-BOUNDP-METHOD-FUNCTION COMMON-LISP::REAL COMMON-LISP::&AUX
+   PCL::DEFAULT-LIMIT-FN PCL::IBCL-LOW S::C-FIXNUM-DOUBLE->
+   PCL::MAP-ALL-GENERIC-FUNCTIONS
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
+   COMMON-LISP::GETHASH PCL::CALLS S::C-FCOMPLEX-FIXNUM-==
+   S::C-DCOMPLEX-FIXNUM-== PCL::NAMES COMMON-LISP::CLEAR-OUTPUT
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|
+   PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
+   PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
+   COMMON-LISP::COMPLEXP PCL::MAKE-PATHNAME-INTERNAL COMMON-LISP::STEP
+   S::*FIXNUM PCL::|(WRITER SOURCE)| PCL::SIMPLE-P PCL::|CACHE SLOT9|
+   PCL::RESET-CLASS-INITIALIZE-INFO-1 PCL::FALSE
+   PCL::*SGF-ARG-INFO-INDEX* PCL::SCASE COMMON-LISP::*STANDARD-INPUT*
+   S::C-SET-STREAM-BUFFER PCL::NAMEP PCL::MAKE-TRAMPOLINE
+   PCL::DEFAULT-STRUCTURE-TYPE PCL::COPY-CHECKING PCL::MCASE
+   PCL::COPY-INSTANCE-INTERNAL COMMON-LISP::APPLY
+   PCL::PRECOMPUTE-EFFECTIVE-METHODS PCL::*EXPORTS*
+   COMMON-LISP::WITH-OPEN-STREAM PCL::DEFAULT-INITARGS-FUNCTION
+   PCL::DEFAULT-INITARGS-METHODS PCL::PV-CELL PCL::CLASS-SUBS
+   PCL::DISPATCH PCL::GENERIC-FUNCTION-PRETTY-ARGLIST PCL::DSLOTDS
+   PCL::ESLOTDS COMMON-LISP::ECASE PCL::DFUN-WRAPPERS-TAIL
+   COMMON-LISP::CCASE COMMON-LISP::&REST S::C-FCOMPLEX-DOUBLE-==
+   S::C-DCOMPLEX-DOUBLE-== COMMON-LISP::FCEILING PCL::|CACHE SLOT8|
+   COMMON-LISP::CLRHASH COMMON-LISP::PARSE-INTEGER
+   PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
+   PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
+   PCL::EFFECTIVE-METHOD-GENSYM-9 COMMON-LISP::LOGANDC2
+   PCL::FIND-FREE-CACHE-LINE PCL::CPD-AFTER PCL::ITEM
+   PCL::DOCUMENTATION-MIXIN-SIMPLE-TYPEP-FN PCL::*SGF-WRAPPER*
+   PCL::|PCL::DEPENDENT-UPDATE-MIXIN class predicate| PCL::ADDS
+   PCL::LEN COMMON-LISP::COUNT PCL::EMIT-CHECKING-OR-CACHING-MACRO
+   PCL::FUN PCL::GENERIC-FUNCTION-CLASS
+   COMMON-LISP::DIRECTORY-NAMESTRING PCL::CODE-CONVERTER
+   COMMON-LISP::PRIN1 COMMON-LISP::READ PCL::POWER-OF-TWO-CEILING
+   COMMON-LISP::CDDR PCL::|CACHE SLOT7| PCL::COPY-NO-METHODS
+   PCL::EFFECTIVE-METHOD-GENSYM-8 PCL::|(WRITER METHOD)|
+   COMMON-LISP::*COMPILE-PRINT* COMMON-LISP::ODDP
+   COMMON-LISP::PACKAGE-SHADOWING-SYMBOLS PCL::LOAD-PCL PCL::HEAD
+   PCL::NAME-OR-MODULE PCL::GF-CALL PCL::CHOICE COMMON-LISP::STRING>
+   PCL::*COMPILER-SPEED* S::C-T-MELTSIZE
+   PCL::FIND-CLASS-PREDICATE-FROM-CELL PCL::FIND-CLASS-FROM-CELL
+   COMMON-LISP::USER-HOMEDIR-PATHNAME COMMON-LISP::LAST
+   PCL::EARLY-SLOT-DEFINITION-LOCATION PCL::BRAID-P PCL::FROM
+   S::C-SET-ARRAY-RANK S::C-HASHTABLE-TEST COMMON-LISP::BIT-ANDC2
+   PCL::|CACHE SLOT6| PCL::LOAD-ENV PCL::EFFECTIVE-METHOD-GENSYM-7
+   PCL::*ALLOW-EXPERIMENTAL-SPECIALIZERS-P* PCL::WRAPPER-FOR-STRUCTURE
+   PCL::COMPILED PCL::TEM COMMON-LISP::HANDLER-BIND ITERATE::ITERATE*
+   PCL::EMIT-CHECKING PCL::SKIP-WHEN-INSTANCE-BOUNDP
+   PCL::*PV-KEY-TO-PV-TABLE-TABLE* PCL::N-POPPED COMMON-LISP::REM
+   PCL::ARG-INFO-METATYPES COMMON-LISP::MAKE-SYMBOL
+   COMMON-LISP::MAPHASH S::C-CFDATA-PROF COMMON-LISP::STRING= PCL::STR
+   COMMON-LISP::ASIN PCL::|CACHE SLOT5| PCL::EFFECTIVE-METHOD-GENSYM-6
+   PCL::BOUNDPS COMMON-LISP::SQRT PCL::PREVIOUS-SLOT-NAMES
+   PCL::|(BOUNDP OPTIONS)| PCL::|(BOUNDP METHODS)| PCL::PROTO-NEW-CLASS
+   PCL::DEFAULT-CODE-CONVERTER COMMON-LISP::CDR COMMON-LISP::PROG
+   PCL::VARS PCL::ARG-INFO-NKEYS PCL::*PCL-SYSTEM-DATE*
+   PCL::METHODS-CONVERTER COMMON-LISP::ROUND PCL::|CACHE SLOT4|
+   COMMON-LISP::STRING< PCL::MAKE-CACHING-DFUN
+   PCL::EFFECTIVE-METHOD-GENSYM-5 PCL::PATH
+   PCL::GENERIC-CLOBBERS-FUNCTION PCL::EMIT-N-N-WRITERS
+   PCL::MEC-ALL-CLASS-LISTS S::C-HASHTABLE-NENT
+   COMMON-LISP::STRING-LEFT-TRIM PCL::ARG-INFO-NUMBER-REQUIRED
+   COMMON-LISP::TAILP S::C-CFDATA-NAME PCL::ARG-INFO-KEYWORDS
+   PCL::FUNCTION-NAME PCL::DESCRIPTION
+   PCL::|(BOUNDP DIRECT-SUPERCLASSES)|
+   PCL::|(BOUNDP DIRECT-SUBCLASSES)| COMMON-LISP::CHARACTER
+   COMMON-LISP::CHARACTERP S::C-FIXNUM-FCOMPLEX-==
+   S::C-FIXNUM-DCOMPLEX-== COMMON-LISP::FILE-ERROR-PATHNAME
+   PCL::MAKE-FIND-CLASS-CELL COMMON-LISP::SYMBOL-PLIST
+   PCL::METACLASS-NAME PCL::|(BOUNDP BOUNDP-FUNCTION)|
+   PCL::REAL-INVALID-METHOD-ERROR COMMON-LISP::Y-OR-N-P
+   COMMON-LISP::SERIOUS-CONDITION PCL::METHODS-FUNCTION
+   PCL::|CACHE SLOT3| PCL::MASK PCL::EFFECTIVE-METHOD-GENSYM-4
+   COMMON-LISP::ENCODE-UNIVERSAL-TIME PCL::POSSIBLY-APPLICABLE-METHODS
+   PCL::GENERIC-FUNCTION-INITIAL-METHODS PCL::SAUT-NOT-PROTOTYPE
+   PCL::PV-SIZE COMMON-LISP::REMHASH PCL::COPY-ONE-INDEX PCL::.SLOTS0.
+   PCL::.SLOTS1. PCL::.SLOTS2. PCL::.SLOTS3.
+   PCL::|(BOUNDP DIRECT-METHODS)| PCL::|(BOUNDP DIRECT-SLOTS)|
+   COMMON-LISP::WARN PCL::INTERCEPT-REBINDINGS
+   PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION PCL::ACCESSOR-METHOD-CLASS
+   PCL::NEW-CLASS-NAME PCL::*CHAPTER-6-EXPORTS*
+   PCL::*COMPILED-INITIALIZE-INSTANCE-SIMPLE-FUNCTIONS*
+   ITERATE::EACHTIME PCL::|(BOUNDP METHOD-COMBINATION)|
+   PCL::|(BOUNDP INTERNAL-READER-FUNCTION)|
+   PCL::|(BOUNDP INTERNAL-WRITER-FUNCTION)| PCL::GENERIC-FUNCTION-NREQ
+   PCL::MFF PCL::CLASS-FORM PCL::ORDER PCL::|(READER SOURCE)| PCL::FROB
+   PCL::PV-REF PCL::|CACHE SLOT2| PCL::EFFECTIVE-METHOD-GENSYM-3
+   PCL::|(BOUNDP METHOD-CLASS)| PCL::FAST-INSTANCE-BOUNDP-INDEX
+   PCL::ACCESSOR-MISS-FUNCTION PCL::DO-COLUMN PCL::TYPE-TEST-COST
+   PCL::WRAPPER-CLASS-SLOTS ITERATE::*ITERATE-WARNINGS*
+   PCL::MAKE-INSTANCE-FUNCTION-COMPLEX PCL::CLASS-NO-OF-INSTANCE-SLOTS
+   PCL::FIND-CLASS-CELL-PREDICATE PCL::FIND-CLASS-PREDICATE
+   PCL::.CALLS. S::C-SET-CFDATA-PROF PCL::MAYBE-APP-P PCL::NAME2
+   PCL::|(BOUNDP FAST-FUNCTION)| COMMON-LISP::IMPORT COMMON-LISP::CDAR
+   PCL::*SGF-NAME-INDEX* PCL::SS COMMON-LISP::RATIONALIZE
+   S::C-SET-ARRAY-ELTTYPE PCL::NAME1 PCL::|CACHE SLOT1| PCL::FORMS
+   PCL::EFFECTIVE-METHOD-GENSYM-2 PCL::SC PCL::ALIST-CELL
+   PCL::KLIST-CELL PCL::EXPAND-DEFCLASS PCL::FSC-P
+   PCL::FAST-BOUNDP-METHOD PCL::DATA PCL::COPY-ONE-CLASS
+   COMMON-LISP::HASH-TABLE-P COMMON-LISP::FLOATING-POINT-OVERFLOW
+   COMMON-LISP::FLOATING-POINT-UNDERFLOW COMMON-LISP::NSTRING-UPCASE
+   PCL::MC PCL::N-N-ACCESSORS-LIMIT-FN PCL::IC
+   PCL::|(CALL STANDARD-COMPUTE-EFFECTIVE-METHOD)|
+   PCL::*CACHE-EXPAND-THRESHOLD* PCL::ARG-INFO-PRECEDENCE
+   PCL::NET-CONSTANT-CONVERTER PCL::STRUCTURE-OBJECT-P
+   COMMON-LISP::CASE COMMON-LISP::BREAK PCL::PV-TABLEP
+   PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME S::C-SET-SYMBOL-PAD3
+   COMMON-LISP::MAKE-CONCATENATED-STREAM S::C-FUNCTION-DATA
+   PCL::|CACHE SLOT0| PCL::ICU S::C-T-MELTMODE PCL::EXTENSION
+   PCL::EFFECTIVE-METHOD-GENSYM-1 PCL::|(READER METHOD)| PCL::TRANS
+   COMMON-LISP::COMPILE COMMON-LISP::+++
+   PCL::GENERIC-FUNCTION-SIMPLE-TYPEP-FN PCL::USES PCL::ECD-CLASS-NAME
+   COMMON-LISP::ATAN COMMON-LISP::STRING-RIGHT-TRIM
+   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS PCL::ALL-APPLICABLE-P
+   PCL::|(BOUNDP FROM-DEFCLASS-P)| S::C-SET-CFDATA-NAME
+   PCL::|(BOUNDP DFUN-STATE)| PCL::NEW-SLOT PCL::*FREE-CACHES*
+   PCL::GF-LL COMMON-LISP::SHORT-FLOAT-EPSILON
+   COMMON-LISP::SHORT-FLOAT-NEGATIVE-EPSILON PCL::MAKE-CACHING
+   PCL::|PCL::DEFINITION-SOURCE-MIXIN class predicate|
+   PCL::FMC-ARG-INFO S::C-SET-SYMBOL-PAD2 PCL::COMPARE
+   PCL::*PV-TABLE-CACHE-UPDATE-INFO* PCL::EFFECTIVE-METHOD-GENSYM-0
+   COMMON-LISP::FILL-POINTER PCL::REAL-MAKE-A-METHOD
+   COMMON-LISP::COUNT-IF PCL::MAKE-WRAPPER-INTERNAL
+   PCL::EMIT-ONE-INDEX-WRITERS PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS
+   PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS PCL::OSEP COMMON-LISP::RATIONALP
+   PCL::NSEP PCL::SLOT-VALUE-USING-CLASS-DFUN
+   PCL::PRECOMPILE-FUNCTION-GENERATORS
+   PCL::PRECOMPILE-DFUN-CONSTRUCTORS COMMON-LISP::NOTEVERY
+   PCL::CLASS-EQ-SPECIALIZER COMMON-LISP::CDDADR
+   COMMON-LISP::FLOATING-POINT-INEXACT PCL::LINE-LOCATION
+   COMMON-LISP::FILE-POSITION PCL::WINNERS COMMON-LISP::CADADR
+   COMMON-LISP::MAKE-PATHNAME PCL::ARG-P PCL::|(BOUNDP PROTOTYPE)|
+   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION PCL::RUN-TIME-VARS
+   PCL::.METH. PCL::|ONE-CLASS SLOT3| COMMON-LISP::SYMBOL-FUNCTION
+   PCL::|(BOUNDP CAN-PRECEDE-LIST)|
+   PCL::DIRECT-SLOT-DEFINITION-SIMPLE-TYPEP-FN
+   PCL::CHECKING-OR-CACHING-LIST PCL::CHECKING-OR-CACHING-FUNCTION-LIST
+   PCL::ENTRY PCL::LOCATION-MATCHES-WRAPPERS-P PCL::WRAPPEDP
+   COMMON-LISP::CDDAAR COMMON-LISP::ARRAY-HAS-FILL-POINTER-P
+   PCL::ERRORP PCL::PUSH-INITARG COMMON-LISP::MAPL COMMON-LISP::CADAAR
+   COMMON-LISP::SBIT PCL::|(BOUNDP SLOT-DEFINITION)|
+   COMMON-LISP::SECOND PCL::EARLY-ADD-NAMED-METHOD PCL::CACHE-P
+   PCL::GCL_PCL_SLOTS_BOOT PCL::METHOD-PRETTY-ARGLIST
+   S::C-SET-CHARACTER-FONT
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION
+   PCL::|(BOUNDP LAMBDA-LIST)| COMMON-LISP::COPY-SEQ
+   S::C-SET-CHARACTER-BITS PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
+   COMMON-LISP::WITH-OPEN-FILE S::C-PACKAGE-USELIST
+   S::C-PACKAGE-USEDBYLIST PCL::RUN-TIME-VALS PCL::TYPES-REV
+   PCL::ARG-INFO-READER COMMON-LISP::EXPORT
+   PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION
+   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::NEW-TAIL
+   PCL::|(BOUNDP FUNCTION)| PCL::|(BOUNDP GENERIC-FUNCTION)|
+   PCL::MAKE-DISPATCH S::C-PATHNAME-VERSION COMMON-LISP::DOCUMENTATION
+   COMMON-LISP::*COMPILE-FILE-PATHNAME*
+   COMMON-LISP::*COMPILE-FILE-TRUENAME* PCL::*THE-WRAPPER-OF-ARRAY*
+   PCL::NON-ARG-P PCL::TYPES-FROM-ARGUMENTS PCL::GF-KEYWORDS
+   COMMON-LISP::POSITION-IF PCL::EMIT-ONE-INDEX-READERS
+   PCL::EARLY-SLOT-DEFINITION-NAME PCL::MAKE-COMPILE-TRANSFORMATION
+   PCL::ARG-INFO-KEY/REST-P COMMON-LISP::BOOLE-ANDC2 PCL::SET-SLOT
+   PCL::CONST PCL::LOCATION-LINE PCL::CHECKING-FUNCTION
+   COMMON-LISP::CDAADR PCL::|INITIALIZE-INFO SLOT13|
+   COMMON-LISP::CAAADR PCL::*OLD-C-A-M-GF-METHODS* PCL::ADD-FORMS
+   PCL::MAKE-INSTANCE-FUNCTION PCL::MAKE-INSTANCE-METHODS PCL::%FBOUNDP
+   PCL::POSSIBLY-APPLICABLE-P COMMON-LISP::STREAM-ERROR
+   PCL::INITFUNCTION COMMON-LISP::*COMPILE-VERBOSE*
+   PCL::*THE-WRAPPER-OF-COMPLEX* PCL::APP-P
+   PCL::*THE-WRAPPER-OF-BIT-VECTOR* PCL::*THE-WRAPPER-OF-CHARACTER*
+   PCL::*THE-WRAPPER-OF-VECTOR* PCL::PRETTY-ARGLIST
+   PCL::EXPAND-MAKE-INSTANCE-FORM PCL::ACCESSOR-CLASS PCL::CORAL
+   PCL::*PCL-DIRECTORY*
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRECOMPILED
+   PCL::KEYWORD-SPEC-NAME S::C-T-CFW PCL::TEST-CONVERTER
+   COMMON-LISP::BOOLE-ANDC1 PCL::DFUN-UPDATE PCL::*INITIAL-PV-TABLE*
+   COMMON-LISP::FLOATING-POINT-INVALID-OPERATION COMMON-LISP::CDAAAR
+   PCL::KEY-LIST COMMON-LISP::CONSP PCL::STRUCTURE-FUNCTIONS-EXIST-P
+   PCL::STRUCTURE-INSTANCE-P COMMON-LISP::GET-PROPERTIES
+   COMMON-LISP::CAAAAR PCL::*COMPILE-MAKE-INSTANCE-FUNCTIONS-P*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
+   COMMON-LISP::INTEGER-DECODE-FLOAT PCL::COPY-MODULE
+   PCL::|(BOUNDP ALLOCATION)| PCL::|(SETF SLOT-DEFINITION-INITARGS)|
+   PCL::USED COMMON-LISP::STRING-GREATERP PCL::N-N-ACCESSOR-TYPE
+   PCL::|INITIALIZE-INFO SLOT12| COMMON-LISP::EXTENDED-CHAR
+   PCL::CACHE-OVERFLOW PCL::LOOSE COMMON-LISP::MAPC
+   PCL::*THE-WRAPPER-OF-RATIO*
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT3| PCL::SLOT-VALUE-NORMAL
+   PCL::FGEN-TEST S::C-HASHTABLE-RHTHRESH PCL::LOAD-SHORT-DEFCOMBIN
+   PCL::COPY-DEFAULT-METHOD-ONLY PCL::PRETTY-CLASS
+   COMMON-LISP::SYNONYM-STREAM PCL::COMPUTE-LAYOUT
+   PCL::ECD-OTHER-INITARGS PCL::|(BOUNDP INITIAL-METHODS)|
+   PCL::NO-METHODS-DFUN-INFO PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P
+   PCL::BRAID PCL::|(BOUNDP SLOT-NAME)|
+   PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::NEXT-LOCATION PCL::LOAD-MODULE
+   SYSTEM::MACRO PCL::SUPERS PCL::UPDATE-CONSTRUCTORS
+   PCL::WRAPPER-CACHE-NUMBER-LENGTH
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS* PCL::|INITIALIZE-INFO SLOT11|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITARGS)| PCL::COPY-DFUN-INFO
+   PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT2| PCL::NEW-PV
+   PCL::*COMPILE-LAMBDA-BREAK-P* PCL::SAUT-NOT-CLASS
+   PCL::*THE-WRAPPER-OF-T* COMMON-LISP::PROGRAM-ERROR
+   PCL::MAKE-EARLY-CLASS-DEFINITION PCL::MEMF-CONSTANT-CONVERTER
+   PCL::SET-SLOT-VALUE-NORMAL
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRAPPER)| PCL::VALS PCL::ORIG
+   COMMON-LISP::TRACE PCL::ARGS SYSTEM::NANI PCL::CACHING-MISS
+   PCL::SHOW-DFUN-COSTS COMMON-LISP::TANH PCL::|(BOUNDP INITFORM)|
+   PCL::CLASS-OR-NAME S::C-FUNCTION-PLIST
+   PCL::*THE-WRAPPER-OF-RATIONAL* PCL::|INITIALIZE-INFO SLOT10|
+   PCL::OUTERS PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT1|
+   COMMON-LISP::UNLESS COMMON-LISP::FFLOOR PCL::LOAD-FUNCTION-GENERATOR
+   PCL::REF PCL::|(BOUNDP WRITERS)| COMMON-LISP::STORE-VALUE
+   ITERATE::UNTIL PCL::SYSTEM-DEFINITION PCL::ACCESSOR-FLAGS
+   PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
+   PCL::*THE-CLASS-FLOAT* PCL::APPLICABLE-METHODS PCL::WRAPPER0
+   PCL::*THE-WRAPPER-OF-NUMBER* PCL::STRUCTURE-CLASS-P
+   PCL::*THE-CLASS-CONS*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ARG-INFO)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITIALIZE-INFO)|
+   COMMON-LISP::ARRAY-TOTAL-SIZE-LIMIT PCL::MODULE-PORT
+   PCL::|(BOUNDP INITFUNCTION)| PCL::|(BOUNDP WRITER-FUNCTION)|
+   PCL::BIND-LEXICAL-METHOD-FUNCTIONS PCL::ACCESSOR-VALUES
+   PCL::REMOVE-WRITER-METHOD COMMON-LISP::SIMPLE-TYPE-ERROR
+   PCL::COMPUTE-PV-SLOT PCL::|CLASS-PRECEDENCE-DESCRIPTION SLOT0|
+   PCL::MAKE-CLASS-EQ-PREDICATE PCL::MAKE-CLASS-PREDICATE
+   COMMON-LISP::BOOLE COMMON-LISP::DECODE-UNIVERSAL-TIME
+   PCL::UPDATE-INITS PCL::|MODULE SLOT4| PCL::COPY-INITIAL
+   PCL::EMIT-DEFAULT-ONLY PCL::|(SETF SLOT-ACCESSOR-STD-P)|
+   PCL::.NEW-VALUE. PCL::SUPPLIED-INITARGS
+   PCL::|(BOUNDP ARGUMENTS-LAMBDA-LIST)| PCL::SCAN-SETF
+   PCL::UPDATE-INITIALIZE-INFO-INTERNAL
+   PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD PCL::*THE-CLASS-NULL*
+   S::C-DOUBLE-DOUBLE-==
+   PCL::MAKE-LOAD-WITHOUT-DEPENDENCIES-TRANSFORMATION PCL::WR
+   PCL::SORT-SLOTS PCL::COPY-SLOTS PCL::UPDATE-SLOTS COMMON-LISP::CADDR
+   PCL::*THE-CLASS-LIST* COMMON-LISP::INVOKE-RESTART PCL::SLOTS-FETCHER
+   PCL::SLOT-NAMES-FOR-PV-TABLE-UPDATE PCL::*THE-WRAPPER-OF-SEQUENCE*
+   COMMON-LISP::INTEGER PCL::CLASS-CELL COMMON-LISP::OR
+   PCL::DFUN-INFO-INDEX PCL::UPDATE-CLASS PCL::T2 PCL::NR
+   COMMON-LISP::UNINTERN PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE PCL::S2
+   SYSTEM::C-DOUBLE-== PCL::SORTED-SLOTS COMMON-LISP::ASSOC-IF
+   COMMON-LISP::STREAM PCL::|MODULE SLOT3| PCL::GCL_PCL_DEFCLASS
+   PCL::*THE-WRAPPER-OF-SYMBOL* PCL::ACCESSOR-DFUN-INFO-P PCL::PRIMARY
+   PCL::IIS-ENTRY PCL::I2 PCL::MAKE-TOP-LEVEL-FORM
+   PCL::MAKE-PERMUTATION-VECTOR PCL::ARG-INFO-VALID-P
+   PCL::*THE-CLASS-STRUCTURE-OBJECT* PCL::*THE-CLASS-STANDARD-OBJECT*
+   PCL::*THE-CLASS-SLOT-OBJECT* PCL::EMF-CALL-TRACE-INDEX
+   PCL::*THE-CLASS-SPECIALIZER-WITH-OBJECT*
+   PCL::*THE-CLASS-FUNCALLABLE-STANDARD-OBJECT*
+   PCL::*THE-CLASS-METAOBJECT* PCL::ESLOTD PCL::COERCE-TO-CLASS
+   PCL::TRACED-METHOD-SIMPLE-TYPEP-FN PCL::*THE-CLASS-INTEGER*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SOURCE)| PCL::C2
+   PCL::CLASS-EQ-SPECIALIZER-P
+   PCL::|(SETF SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL)|
+   WALKER::NESTED-WALK-FORM PCL::WALK COMMON-LISP::VALUES
+   COMMON-LISP::*READTABLE* COMMON-LISP::CADAR PCL::EARLY-GF-ARG-INFO
+   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|
+   PCL::WRITER-FUNCTION 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 PCL::MAKE-CHECKING
+   PCL::COPY-METHOD-CALL PCL::|(BOUNDP DEFSTRUCT-FORM)|
+   PCL::TRUTH-VALUE PCL::THUNK-NAME COMMON-LISP::SIGNAL
+   PCL::|PCL::STD-CLASS class predicate| PCL::CALL
+   PCL::*THE-CLASS-STANDARD-EFFECTIVE-SLOT-DEFINITION*
+   PCL::*THE-CLASS-STANDARD-GENERIC-FUNCTION*
+   PCL::*THE-CLASS-GENERIC-FUNCTION*
+   PCL::*THE-CLASS-LONG-METHOD-COMBINATION*
+   PCL::*THE-CLASS-STANDARD-METHOD-COMBINATION*
+   PCL::*THE-CLASS-METHOD-COMBINATION*
+   PCL::*THE-CLASS-STRUCTURE-EFFECTIVE-SLOT-DEFINITION*
+   PCL::*THE-CLASS-STRUCTURE-DIRECT-SLOT-DEFINITION*
+   PCL::*THE-CLASS-STANDARD-DIRECT-SLOT-DEFINITION*
+   PCL::*THE-CLASS-EFFECTIVE-SLOT-DEFINITION*
+   PCL::*THE-CLASS-DIRECT-SLOT-DEFINITION*
+   PCL::*THE-CLASS-STRUCTURE-SLOT-DEFINITION*
+   PCL::*THE-CLASS-STANDARD-SLOT-DEFINITION*
+   PCL::*THE-CLASS-SLOT-DEFINITION* PCL::*THE-CLASS-FUNCTION*
+   COMMON-LISP::STRING-TRIM PCL::|MODULE SLOT2|
+   PCL::|PCL::PCL-CLASS class predicate| PCL::ADJUST-SLOT-NAME-LENGTH
+   COMMON-LISP::CONCATENATED-STREAM-STREAMS COMMON-LISP::PPRINT-INDENT
+   PCL::NAME PCL::|(BOUNDP PRETTY-ARGLIST)| PCL::SPECIALIZER-CLASS
+   PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS PCL::TYPES1
+   WALKER::MACROEXPAND-ALL PCL::*THE-CLASS-FUNCALLABLE-STANDARD-CLASS*
+   PCL::*THE-CLASS-STANDARD-CLASS* PCL::*THE-CLASS-SLOT-CLASS*
+   PCL::*THE-CLASS-BUILT-IN-CLASS* PCL::*THE-CLASS-CLASS*
+   PCL::*THE-CLASS-STRUCTURE-CLASS* PCL::MAKE-SOURCE-PATHNAME
+   PCL::*THE-CLASS-FORWARD-REFERENCED-CLASS* PCL::*THE-CLASS-STD-CLASS*
+   PCL::*THE-CLASS-PCL-CLASS* PCL::MAKE-INITFUNCTION
+   PCL::REDEFINE-FUNCTION PCL::EXACT-CLASS-SPECIALIZER
+   PCL::METHOD-SIMPLE-TYPEP-FN PCL::STRUCTURE-INSTANCE
+   PCL::SET-ARG-INFO PCL::DSLOTD
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
+   PCL::*METHOD-COMBINATION-ERROR*
+   PCL::CACHED-SHARED-INITIALIZE-T-FUNCTION
+   PCL::CACHED-SHARED-INITIALIZE-NIL-FUNCTION
+   PCL::ACCESSOR-VALUES-INTERNAL
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION) T|
+   PCL::NREQ PCL::*THE-WRAPPER-OF-HASH-TABLE*
+   PCL::*THE-WRAPPER-OF-READTABLE* PCL::CACHING-
+   PCL::UPDATE-DISPATCH-DFUNS
+   PCL::|(BOUNDP IDENTITY-WITH-ONE-ARGUMENT)| PCL::GF?
+   PCL::*THE-CLASS-SYNONYM-STREAM* PCL::*THE-CLASS-ECHO-STREAM*
+   PCL::*THE-CLASS-TWO-WAY-STREAM* PCL::*THE-CLASS-STRING-STREAM*
+   PCL::*THE-CLASS-CONCATENATED-STREAM*
+   PCL::*THE-CLASS-BROADCAST-STREAM* PCL::*THE-CLASS-FILE-STREAM*
+   PCL::*THE-CLASS-STREAM* PCL::FIND-CYCLE-REASONS PCL::|MODULE SLOT1|
+   PCL::GCL_PCL_STD_CLASS PCL::DEFAULT-METHOD-ONLY-
+   PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P
+   PCL::EMIT-N-N-READERS PCL::|(BOUNDP SPECIALIZERS)|
+   PCL::REAL-ENSURE-GF-USING-CLASS--NULL PCL::*NOTE-IIS-ENTRY-P*
+   PCL::*THE-CLASS-REAL* PCL::MAKE-LOAD-TRANSFORMATION
+   PCL::|(BOUNDP DECLARATIONS)| PCL::GET-MODULE PCL::OPOS
+   PCL::.GATHERING1. PCL::MAKE-NO-METHODS PCL::NPOS
+   COMMON-LISP::MAKE-CONDITION PCL::ACCESSOR-METHOD-SLOT-NAME
+   PCL::*DFUN-MISS-GFS-ON-STACK* PCL::SIZE-1 PCL::*THE-CLASS-STRING*
+   PCL::SYMBOL-PKG-NAME COMMON-LISP::*** COMMON-LISP::SYMBOL-NAME
+   PCL::MAX-SLOT-NAME-LENGTH PCL::CHECK-WRAPPER-VALIDITY1
+   COMMON-LISP::TRUENAME PCL::TABLE PCL::FAST-INTERNAL-READER-METHOD
+   PCL::LONG-METHOD-COMBINATION-P PCL::|MODULE SLOT0|
+   PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION
+   COMMON-LISP::STREAM-ERROR-STREAM PCL::SYMBOL-APPEND
+   COMMON-LISP::BIT-ORC2 COMMON-LISP::FIND-ALL-SYMBOLS PCL::WRITER-SYM
+   PCL::|(BOUNDP INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::ENSURE-CLASS-VALUES PCL::CACHE PCL::WCN PCL::.GENERIC-FUNCTION.
+   PCL::SHARED-INITIALIZE-T-FUNCTION
+   PCL::SHARED-INITIALIZE-NIL-FUNCTION PCL::SHARED-INITIALIZE-METHODS
+   COMMON-LISP::STRING-STREAM COMMON-LISP::UNWIND-PROTECT PCL::NPOP
+   PCL::WFT-WRAPPER2 PCL::DEPENDENT-UPDATE-MIXIN PCL::APPL PCL::.PV.
+   PCL::CONSTRUCTOR PCL::READER-SYM S::C-DOUBLE-FIXNUM-==
+   PCL::COPY-CACHE-INTERNAL PCL::*GENERIC-FUNCTION-FIXUPS*
+   PCL::FAST-INSTANCE-BOUNDP-P COMMON-LISP::FIND-IF-NOT
+   S::C-CHARACTER-FONT PCL::EMIT-SLOT-READ-FORM COMMON-LISP::WARNING
+   PCL::MAKE-CONSTANT-FUNCTION PCL::COMPUTE-CALLS
+   PCL::CONVERT-TO-SYSTEM-TYPE COMMON-LISP::STREAMP PCL::PYR-PATCHES
+   S::C-CHARACTER-BITS PCL::REAL-ENSURE-GF-INTERNAL
+   PCL::SYSTEM-DESCRIPTION PCL::*MAKE-INSTANCE-FUNCTION-KEYS*
+   PCL::%SVREF COMMON-LISP::UNDEFINED-FUNCTION PCL::.DOLIST-CAREFULLY.
+   PCL::AFTER-P PCL::IDENTITY-WITH-ONE-ARGUMENT
+   COMMON-LISP::DOUBLE-FLOAT COMMON-LISP::PPRINT-LINEAR
+   COMMON-LISP::ARRAY-DIMENSIONS PCL::WFT-WRAPPER1
+   PCL::SPECIALIZER-OBJECT PCL::SPECIALIZER-WITH-OBJECT
+   PCL::*IN-GF-ARG-INFO-P* COMMON-LISP::DO-ALL-SYMBOLS
+   PCL::|(BOUNDP DOCUMENTATION)| PCL::|(BOUNDP LOCATION)|
+   PCL::SORTED-METHODS PCL::*THE-CLASS-PATHNAME*
+   PCL::*THE-CLASS-LOGICAL-PATHNAME* PCL::*THE-CLASS-PACKAGE*
+   PCL::*THE-CLASS-RANDOM-STATE* COMMON-LISP::ARRAY-DIMENSION-LIMIT
+   COMMON-LISP::ARRAY-DISPLACEMENT PCL::INTERNED-SYMBOL-P
+   COMMON-LISP::CHAR-INT PCL::ECD-CANONICAL-SLOTS COMMON-LISP::ABS
+   COMMON-LISP::NTH PCL::|(BOUNDP ACCESSOR-FLAGS)| PCL::BOUNDP-FUNCTION
+   COMMON-LISP::LOGNOT COMMON-LISP::BIT-NAND COMMON-LISP::MAX
+   PCL::*LIST-ELEMENTS ITERATE::PLIST-ELEMENTS
+   PCL::|(BOUNDP CLASS-PRECEDENCE-LIST)| PCL::GATHERING1
+   ITERATE::GATHERING S::C-DOUBLE-FIXNUM-> PCL::EQL-TEST
+   PCL::OLD-VECTOR PCL::SPEC-LIST COMMON-LISP::LOGNOR
+   PCL::MAKE-CALLS-TYPE-DECLARATION PCL::FORM-LIST
+   COMMON-LISP::COPY-LIST PCL::SET-FUNCTION-PRETTY-ARGLIST
+   PCL::MAKE-CONSTANT-VALUE-DFUN COMMON-LISP::CAADR
+   COMMON-LISP::BIT-VECTOR PCL::NEW-VECTOR PCL::UPDATE-GF-DFUN
+   PCL::UPDATE-DFUN COMMON-LISP::FINISH-OUTPUT
+   COMMON-LISP::MUFFLE-WARNING PCL::POSQ PCL::NO-METHODS-
+   COMMON-LISP::LCM COMMON-LISP::SIMPLE-ARRAY S::C-STREAM-FLAGS
+   PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE PCL::DFUN-LIST
+   COMMON-LISP::SAFETY PCL::CURRENT-SLOTDS COMMON-LISP::EVAL-WHEN
+   PCL::*INITIALIZE-INFO-CACHE-INITARGS* PCL::CALL-LIST PCL::SUB
+   PCL::CASE-LIST COMMON-LISP::MAKE-LIST S::C-DOUBLE-FLOAT->
+   COMMON-LISP::MAKUNBOUND
+   PCL::|PCL::ACCESSOR-DFUN-INFO class predicate|
+   PCL::GET-DFUN-CONSTRUCTOR PCL::TREE
+   COMMON-LISP::STREAM-EXTERNAL-FORMAT
+   PCL::MAKE-BUILT-IN-WRAPPER-OF-BODY-2 PCL::|(BOUNDP READERS)|
+   PCL::*PORT* PCL::TAIL PCL::EXPAND-DEFMETHOD PCL::OUTER-DECLS
+   PCL::DO-BOUNDP-DEFINITION PCL::|(BOUNDP PREDICATE-NAME)|
+   PCL::TYPE-FROM-SPECIALIZER COMMON-LISP::SORT COMMON-LISP::AREF
+   COMMON-LISP::COMPILER-MACRO PCL::INTERRUPTS-ON
+   PCL::TRACE-METHOD-INTERNAL COMMON-LISP::CAAAR PCL::PORT PCL::PRED
+   PCL::FREE PCL::|(BOUNDP READER-FUNCTION)|
+   PCL::PLIST-MIXIN-SIMPLE-TYPEP-FN PCL::MAKE-ONE-INDEX
+   S::C-SET-CHARACTER-NAME PCL::PRINTING-RANDOM-THING-INTERNAL
+   PCL::COPY-PV-TABLE S::ADJUSTABLE-ARRAY PCL::FORMAT-CONTROL
+   COMMON-LISP::COMPILED-FUNCTION-P
+   PCL::MAKE-BUILT-IN-WRAPPER-OF-BODY-1 PCL::TRACE-EMF-CALL
+   PCL::CLASS-MIGHT-PRECEDE-P WALKER::DEFINE-WALKER-TEMPLATE
+   PCL::NO-METHODS-CACHE PCL::SPECS PCL::FROM-DEFCLASS-P
+   COMMON-LISP::ARRAY-TOTAL-SIZE COMMON-LISP::PPRINT-LOGICAL-BLOCK
+   PCL::PCL PCL::CACHED-INITARGS-FORM-LIST PCL::CACHE-VECTOR-LOCK-COUNT
+   PCL::SPECIALIZERS PCL::*INITIALIZE-INFO-CACHE-INFO* S::C-SET-T-XX
+   PCL::KCL PCL::|(FAST-READER-METHOD CLASS CLASS-EQ-SPECIALIZER)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
+   COMMON-LISP::BOUNDP PCL::ALLOCP PCL::GCL
+   COMMON-LISP::DEFINE-SETF-EXPANDER PCL::IBCL
+   PCL::CLASS-METHOD-FUNCTION PCL::WRAPPER-NO-OF-INSTANCE-SLOTS
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::RAW)| PCL::ARGS-TAIL
+   PCL::REAL-LOAD-DEFCLASS SYSTEM::C-OBJECT-==
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME :LAMBDA-LIST :DEFINITION-SOURCE :METHOD-CLASS :METHOD-COMBINATION) NIL|
+   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 :INITFORM :INITARGS :WRITERS :READERS :NAME :INITFUNCTION :CLASS) 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 :DEFINITION-SOURCE :DIRECT-SLOTS :DIRECT-SUPERCLASSES :NAME) 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 :DEFINITION-SOURCE :FUNCTION :LAMBDA-LIST :SPECIALIZERS :QUALIFIERS) 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 :CLASS :TYPE :ALLOCATION :INITARGS :INITFUNCTION :INITFORM :NAME :INTERNAL-WRITER-FUNCTION :INTERNAL-READER-FUNCTION :DEFSTRUCT-ACCESSOR-SYMBOL) 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 :INITFUNCTION :INITFORM :TYPE :INTERNAL-WRITER-FUNCTION :INTERNAL-READER-FUNCTION :DEFSTRUCT-ACCESSOR-SYMBOL :NAME :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 :NAME :DIRECT-SLOTS :DIRECT-SUPERCLASSES :NAME) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME :METHOD-CLASS :METHOD-COMBINATION) 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 :CLASS :TYPE :ALLOCATION :INITARGS :INITFUNCTION :INITFORM :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 :INITARGS :WRITERS :READERS :NAME :CLASS) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :NAME :READERS :WRITERS :INITARGS) NIL|
+   PCL::|MAKE-INSTANCE CLASS-EQ-SPECIALIZER (:CLASS :CLASS) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE :PREDICATE-NAME :PREDICATE-NAME :DEFINITION-SOURCE :DIRECT-SLOTS :DIRECT-SUPERCLASSES :NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE :PREDICATE-NAME) NIL|
+   PCL::|MAKE-INSTANCE EQL-SPECIALIZER (:OBJECT :OBJECT) NIL|
+   PCL::|MAKE-INSTANCE EQL-SPECIALIZER (:OBJECT) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :DEFINITION-SOURCE :LAMBDA-LIST :SPECIALIZERS :QUALIFIERS) 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::SLOT-UNBOUND-INTERNAL COMMON-LISP::LISP-IMPLEMENTATION-TYPE
+   PCL::SYSTEM PCL::DIRECT-SUPERS S::C-STREAM-BUFFER
+   PCL::COMPATIBLE-META-CLASS-CHANGE-P PCL::ACCESSOR-TYPE
+   ITERATE::LIST-TAILS S::C-SET-T-TP S::C-SET-T-TT S::C-SET-T-T
+   PCL::DIRECT-SLOTS PCL::SPECIALIZERS-FORM PCL::MAKE-ONE-CLASS
+   PCL::FAST-LEXICAL-METHOD-FUNCTIONS PCL::SPECIALIZER-SIMPLE-TYPEP-FN
+   PCL::SPECIALIZER-WITH-OBJECT-SIMPLE-TYPEP-FN PCL::GET-FUNCTION
+   PCL::MEMF-CODE-CONVERTER PCL::METHOD-PROTOTYPE-FOR-GF
+   S::C-FUNCTION-MAXARG PCL::PLIST-VALUE PCL::SET-SYSTEM
+   PCL::GET-SYSTEM
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::FROZEN)|
+   PCL::*SLOTD-WRITER-FUNCTION-STD-P* PCL::CHECKING-LIMIT-FN
+   PCL::|(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OPERATOR)|
+   PCL::|(FAST-READER-METHOD SHORT-METHOD-COMBINATION OPERATOR)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT VECTOR)|
+   COMMON-LISP::NTH-VALUE COMMON-LISP::STREAM-ELEMENT-TYPE
+   SYSTEM::REAL-DOCUMENTATION COMMON-LISP::USE-VALUE
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITARGS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITARGS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CALL-METHOD-ARGS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::MACROS)|
+   COMMON-LISP::ADJOIN COMMON-LISP::ENSURE-DIRECTORIES-EXIST PCL::SPECL
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OVERFLOW)|
+   COMMON-LISP::PPRINT-FILL COMMON-LISP::SIMPLE-ERROR S::C-SET-T-PD
+   PCL::COPY PCL::SHARED-INITFNS
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::ARG-TYPES)|
+   PCL::STRING-APPEND PCL::NEW-VALUE PCL::NEW-VALUES
+   PCL::EMIT-READER/WRITER PCL::FORM COMMON-LISP::COSH
+   PCL::|(FAST-READER-METHOD PCL-CLASS WRAPPER)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRAPPER)|
+   S::C-SET-RANDOM-STATE PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN
+   PCL::SUPPLIED-META PCL::|(FAST-READER-METHOD SLOT-OBJECT NLINES)|
+   COMMON-LISP::REVERSE PCL::OTHERS PCL::TRAP PCL::INDEXES
+   PCL::EXACT-CLASS-SPECIALIZER-P
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OWNER)| PCL::CACHE-
+   PCL::*ALLOW-EMF-CALL-TRACING-P* PCL::EMIT-DEFAULT-ONLY-MACRO
+   PCL::LOOKUP-FGEN PCL::W1
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::HAS-HOLES)|
+   COMMON-LISP::IGNORE-ERRORS PCL::CONSTRUCTOR-SYM PCL::DO-ONE-FILL
+   PCL::.IGNORE. PCL::T1 PCL::S1 PCL::ACCESSOR-NAME
+   PCL::PRINTING-RANDOM-THING PCL::LOSE PCL::COMP-ENV PCL::PROTO-METHOD
+   COMMON-LISP::SPEED PCL::DETERMINED-TO-BE PCL::METHOD-GROUP-SPECIFIER
+   S::C-SET-HASHTABLE-MAX_ENT PCL::SPECIALIZERP S::C-FUNCTION-MINARG
+   PCL::NOPT PCL::INNER PCL::WRITER-METHOD COMMON-LISP::EQ PCL::ELEMENT
+   S::C-SET-T-H PCL::I1
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ARG-INFO)|
+   PCL::|(FAST-READER-METHOD SLOT-CLASS INITIALIZE-INFO)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
+   PCL::EMIT-READER/WRITER-MACRO PCL::|(SETF GF-PRETTY-ARGLIST)|
+   COMMON-LISP::UNBOUND-SLOT PCL::SLOT-VECTOR-SYMBOL PCL::C1
+   PCL::FGEN-GENSYMS S::C-SET-T-FW S::C-SET-T-F S::C-SET-T-FF
+   PCL::TRACE-METHOD COMMON-LISP::ENOUGH-NAMESTRING PCL::METATYPES
+   PCL::PRETTY-NAME PCL::|(SETF GENERIC-FUNCTION-METHODS)|
+   PCL::|(SETF GENERIC-FUNCTION-INITIAL-METHODS)|
+   PCL::|(SETF GENERIC-FUNCTION-DECLARATIONS)| PCL::WRITER-NAME
+   PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION-FAST PCL::TRACED-METHOD
+   COMMON-LISP::CONTROL-ERROR PCL::DEPENDENT PCL::DEPENDENTS
+   PCL::DFUN-STATE
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::INCLUDES)|
+   PCL::METHOD-FAST-FUNCTION PCL::COLLECT-FORMS
+   PCL::UPDATE-CLASS-CAN-PRECEDE-P PCL::EMIT-1-NIL-DLAP
+   PCL::EMIT-1-T-DLAP PCL::SLOTDS PCL::SET-DFUN PCL::CACHE-VECTOR
+   PCL::|PCL::FAST-METHOD-CALL class predicate|
+   COMMON-LISP::ARRAY-DIMENSION PCL::INNERS COMMON-LISP::ADJUST-ARRAY
+   COMMON-LISP::SINGLE-FLOAT ITERATE::JOINING PCL::PREVIOUS
+   PCL::..UNSPECIFIC-ARG.. PCL::MORE PCL::ROOT
+   S::C-SET-PATHNAME-DIRECTORY
+   PCL::|(FAST-READER-METHOD DEFINITION-SOURCE-MIXIN SOURCE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SOURCE)| S::C-SET-FUNCTION-ENV
+   S::C-CONS-CDR PCL::FORMAT-STRING COMMON-LISP::NSTRING-DOWNCASE
+   S::C-PACKAGE-INTERNAL_FP S::*FCOMPLEX PCL::*MF2CP* PCL::ARGS-ENTRY
+   S::*DCOMPLEX S::C-PACKAGE-LINK PCL::MODULES PCL::KNOWN-TYPES
+   PCL::PAT PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P
+   PCL::CLASS-DEFSTRUCT-CONSTRUCTOR PCL::SLOT-ENTRY COMMON-LISP::PLUSP
+   PCL::METHOD-ALIST PCL::POST-KEYWORD PCL::DFUN-INFO-FUNCTION
+   PCL::COMPUTE-VALID-P COMMON-LISP::RANDOM PCL::DIRECT-METHODS
+   PCL::NO-EQL-SPECLS-P S::C-T-XX PCL::CHECK-INITARGS-1
+   PCL::SHORT-METHOD-COMBINATION PCL::CALL-ENTRY PCL::ADD
+   COMMON-LISP::MISMATCH S::C-ARRAY-ELTSIZE PCL::SLOT-READER-SYMBOL
+   PCL::|(SETF GENERIC-FUNCTION-METHOD-COMBINATION)|
+   PCL::COMPUTE-STD-CPL PCL::*EFFECTIVE-METHOD-TABLE*
+   PCL::PV-TABLE-CALL-LIST
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION DEFSTRUCT-ACCESSOR-SYMBOL)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
+   PCL::SPECIALIZED-PARAMETERS
+   PCL::|(SETF GENERIC-FUNCTION-METHOD-CLASS)| PCL::*TYPEP
+   PCL::METHOD-CLASS PCL::ARGS+REST-ARG PCL::GF-DFUN-STATE
+   PCL::SPECIALIZED-LAMBDA-LIST PCL::CLAUSES COMMON-LISP::LOOP
+   PCL::NEXT-METHOD-CALL COMMON-LISP::SEQUENCE
+   PCL::SPECIALIZER-FROM-TYPE PCL::SPECIALIZER-TYPE
+   PCL::STRUCTURE-OBJECT- PCL::SPECIALIZER->METATYPE
+   COMMON-LISP::STRING-CAPITALIZE COMMON-LISP::PPRINT-NEWLINE
+   PCL::MAKE-CDXR PCL::CALL-METHOD-ARGS
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD)| COMMON-LISP::CADR
+   COMMON-LISP::DIRECTORY PCL::|__si::MAKE-ONE-INDEX|
+   PCL::PRINT-DFUN-INFO PCL::INITS PCL::BOUNDP-METHOD
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::DEF)|
+   SYSTEM::DEFENTRY PCL::FGEN-GENERATOR PCL::NEW-PREVIOUS
+   PCL::LOCK-COUNT COMMON-LISP::READER-ERROR S::C-T-TT
+   PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN PCL::DFUN-INFO-P PCL::MAKE-MODULE
+   COMMON-LISP::ROOM COMMON-LISP::MULTIPLE-VALUE-LIST
+   PCL::FILL-CACHE-FROM-CACHE-P PCL::MODULE-NAME
+   PCL::*GET-WRAPPER-CACHE-NUMBER*
+   PCL::*GLOBAL-EFFECTIVE-METHOD-GENSYMS* S::C-T-ST PCL::MAKE-CAXR
+   COMMON-LISP::ARITHMETIC-ERROR-OPERANDS PCL::DFUN-COUNT PCL::CDC
+   PCL::INTO PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::INCLUDED)|
+   SYSTEM::STRUCTURE-REF SYSTEM::STRUCTURE-DEF COMMON-LISP::CONS
+   PCL::INST PCL::PARSE-GSPEC PCL::INITP COMMON-LISP::CONJUGATE
+   PCL::ALLOCATE-STANDARD-INSTANCE--MACRO PCL::SPECIALIZERS-OR-METHOD
+   PCL::INNER-DECLS PCL::MAKE-DEFAULT-METHOD-ONLY
+   PCL::CAN-OPTIMIZE-ACCESS PCL::INVOKE-EFFECTIVE-METHOD-FUNCTION
+   COMMON-LISP::HASH-TABLE S::C-T-TP PCL::EARLY-GF-SPEC
+   PCL::|PCL::STANDARD-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-METHOD-COMBINATION class predicate|
+   PCL::*REDEFINED-FUNCTIONS*
+   PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL
+   COMMON-LISP::RASSOC-IF
+   PCL::|PCL::FAST-INSTANCE-BOUNDP class predicate|
+   PCL::METHOD-NAME-DECLARATION PCL::EFFECTIVE COMMON-LISP::*FEATURES*
+   COMMON-LISP::ASH S::C-ARRAY-SELF PCL::EARLY-METHOD-SPECIALIZERS
+   COMMON-LISP::FORMAT COMMON-LISP::FLOAT-DIGITS PCL::LIST-DFUN
+   PCL::TIE-BREAKER SYSTEM::ARRAY-DIMS
+   PCL::|PCL::ARG-INFO class predicate| ITERATE::MINIMIZING
+   PCL::SHORT-METHOD-COMBINATION-SIMPLE-TYPEP-FN PCL::INITIAL-METHODS
+   PCL::MAKE-DFUN-INFO PCL::FILL-DFUN-CACHE SYSTEM::STRUCTUREP
+   COMMON-LISP::STRUCTURE PCL::|__si::MAKE-TWO-CLASS|
+   PCL::|__si::MAKE-ONE-CLASS| PCL::*MF2P* PCL::REQUIRED-CHECKS
+   ITERATE::MAXIMIZING PCL::CACHING-CACHE PCL::VAR PCL::LMF-OPTIONS
+   S::C-PACKAGE-EXTERNAL_FP PCL::INSURE-CACHING-DFUN PCL::OCLASS-SLOTS
+   PCL::CALLSREF PCL::*EARLY-P* S::C-PACKAGE-INTERNAL
+   COMMON-LISP::REDUCE PCL::DO-ONE-FILL-FROM-LINE S::C-ARRAY-DIM
+   PCL::COMPILE-PCL PCL::FAST-METHOD-CALL-ARG-INFO COMMON-LISP::LDB
+   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN PCL::OBJECT-PLIST
+   COMMON-LISP::DECODE-FLOAT PCL::ACCESSORS
+   COMMON-LISP::STRING-NOT-GREATERP
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE
+   COMMON-LISP::PATHNAME-DIRECTORY PCL::|(SETF GENERIC-FUNCTION-NAME)|
+   COMMON-LISP::CAR COMMON-LISP::UNION PCL::EARLY-METHOD-LAMBDA-LIST
+   PCL::XEROX-LOW S::C-CHARACTER-NAME PCL::WFT-TYPE1 PCL::PATTERNS
+   COMMON-LISP::COPY-READTABLE S::C-T-W PCL::GET-CPD
+   COMMON-LISP::VALUES-LIST PCL::NAMED-OBJECT-PRINT-FUNCTION
+   PCL::INITIAL-DFUN PCL::EQL-SPECIALIZER-P PCL::VALSYM
+   PCL::*DESCRIBE-METAOBJECTS-AS-OBJECTS-P* COMMON-LISP::GENTEMP
+   COMMON-LISP::NREVERSE COMMON-LISP::LOGTEST
+   PCL::CHANGE-CLASS-INTERNAL PCL::REQUIRED-ARGS PCL::OTHER-SLOTDS
+   S::C-T-T PCL::*LIST-TAILS COMMON-LISP::BIT-AND
+   PCL::EARLY-METHOD-CLASS PCL::CLASS-METHOD PCL::MAKE-INITIAL
+   PCL::GENERA PCL::LAMBDA-LIST S::C-PACKAGE-NAME PCL::READER-FUNCTION
+   ITERATE::SUMMING PCL::OW1 PCL::CYCLE-REASONS PCL::CACHE-VECTOR-SIZE
+   COMMON-LISP::PATHNAME-HOST COMMON-LISP::SPACE
+   PCL::UPDATE-STD-OR-STR-METHODS S::C-SET-T-MELTTYPE
+   PCL::MAKE-DFUN-CALL S::C-T-PD PCL::LIST-EQ
+   COMMON-LISP::BROADCAST-STREAM-STREAMS
+   PCL::*INVALIDATE-DISCRIMINATING-FUNCTION-FORCE-P*
+   COMMON-LISP::LDB-TEST PCL::PKG-LIST PCL::WRITERS-INIT
+   S::C-HASHTABLE-PAD5 COMMON-LISP::GET-SETF-EXPANSION
+   COMMON-LISP::SUBSTITUTE-IF S::C-T-MF S::C-SET-PATHNAME-HOST
+   PCL::COMPUTE-CODE SYSTEM::~ PCL::FAST-METHOD-CALL
+   PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL PCL::FAST-METHOD-CALL-PV-CELL
+   SYSTEM::|\|| PCL::+PCL+ PCL::GENSYMS PCL::DIRECT-SLOTS-P
+   PCL::COLLECT-GFS PCL::NEW-STATE PCL::NEW-SPECIALIZER
+   COMMON-LISP::END-OF-FILE PCL::CANONICAL S::C-T-M
+   COMMON-LISP::VECTOR-PUSH-EXTEND PCL::|ACCESSOR-DFUN-INFO SLOT1|
+   PCL::*INVALID-DFUNS-ON-STACK* S::C-ARRAY-ELTMODE
+   PCL::MAKE-METHOD-CALL PCL::|PCL::PV-TABLE class predicate|
+   PCL::%CCLOSURE-ENV COMMON-LISP::LOGNAND COMMON-LISP::TYPECASE
+   S::C-HASHTABLE-PAD4 PCL::GET-PV-CELL-FOR-CLASS PCL::*UMI-GFS*
+   PCL::LOAD-DEFGENERIC COMMON-LISP::SIMPLE-STRING-P
+   COMMON-LISP::SIMPLE-STRING COMMON-LISP::SUBSTITUTE-IF-NOT
+   COMMON-LISP::RASSOC COMMON-LISP::CAAR S::C-PACKAGE-EXTERNAL
+   PCL::MODULE PCL::OW0 PCL::W0 SYSTEM::^ PCL::LIST-ALL-DFUNS
+   PCL::CALL-INITIALIZE-FUNCTION PCL::FIND-SLOT-DEFINITION
+   COMMON-LISP::PARSE-NAMESTRING PCL::MP
+   COMMON-LISP::*MACROEXPAND-HOOK* COMMON-LISP::MAP PCL::ALLOCATE-MACRO
+   PCL::|__si::MAKE-NO-METHODS|
+   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION| PCL::Y
+   COMMON-LISP::COND PCL::X S::C-T-FF PCL::W PCL::USE PCL::CPL2
+   COMMON-LISP::SIMPLE-WARNING PCL::V PCL::INSTANCE-SLOTS-LAYOUT
+   S::C-HASHTABLE-PAD3 S::C-SET-FUNCTION-NEVAL COMMON-LISP::T S::C-T-H
+   PCL::S PCL::INSTANCE-ESLOTDS PCL::R PCL::REMOVE-READER-METHOD
+   PCL::GF-NOPT COMMON-LISP::DESCRIBE PCL::Q PCL::P
+   PCL::*WRAPPER-OF-COST* PCL::SUB-TESTS PCL::SET-FUNCTION-NAME
+   PCL::FUNCALLABLE-STANDARD-OBJECT PCL::O PCL::N PCL::CPL1
+   COMMON-LISP::RETURN-FROM PCL::M PCL::L PCL::COMPILE-LAMBDA PCL::K
+   PCL::FORM-LIST-TO-LISP PCL::J PCL::I COMMON-LISP::CTYPECASE
+   COMMON-LISP::ETYPECASE S::C-T-F PCL::G PCL::F
+   PCL::FUNCALLABLE-STANDARD-CLASS-WRAPPER S::C-SET-FUNCTION-SELF
+   PCL::E PCL::D PCL::C PCL::WALKED-LAMBDA-BODY PCL::B
+   COMMON-LISP::SOME S::C-T-E PCL::A COMMON-LISP::LABELS PCL::OBJ
+   COMMON-LISP::> S::C-HASHTABLE-PAD2 COMMON-LISP::= COMMON-LISP::<
+   PCL::EARLY-NAME PCL::BINDINGS PCL::IDENTITY-WITH-ONE-ARG
+   PCL::LINE-RESERVED-P PCL::HOME
+   PCL::FUNCALLABLE-INSTANCE-DATA-POSITION
+   PCL::CACHED-MAKE-INSTANCE-FUNCTION S::C-SYMBOL-PLIST
+   PCL::MAKE-INITIAL-DFUN PCL::COMMON COMMON-LISP::SHADOW
+   PCL::POSS-APPL COMMON-LISP::/ PCL::EARLY-METHOD-FUNCTION
+   COMMON-LISP::- PCL::SHORT-COMBINATION-IDENTITY-WITH-ONE-ARGUMENT
+   PCL::SLL-DECL PCL::ADD-READER-METHOD PCL::PRINT-STD-INSTANCE
+   COMMON-LISP::+
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::FUN-VALUES)|
+   COMMON-LISP::* PCL::BUILT-IN-OR-STRUCTURE-WRAPPER
+   PCL::METHOD-FUNCTION-PLIST
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::OFFSET)| SYSTEM::&
+   S::C-HASHTABLE-PAD1 S::% COMMON-LISP::DELETE PCL::*MF1CP*
+   PCL::NON-SETF-VAR PCL::FALSE-VALUE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
+   COMMON-LISP::PATHNAMEP COMMON-LISP::SET-DIFFERENCE PCL::SLOTS
+   PCL::METHOD-CALL-FUNCTION COMMON-LISP::TYPE-OF
+   COMMON-LISP::VECTOR-PUSH PCL::PARSE-METHOD-GROUP-SPECIFIER
+   PCL::CDR-OF-FORM PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VALUEP)|
+   COMMON-LISP::MACHINE-VERSION PCL::INTERRUPTS-OFF COMMON-LISP::GCD
+   PCL::OBJECT-VAR PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PORT)|
+   PCL::ECD PCL::LINE-1 COMMON-LISP::OPEN-STREAM-P
+   PCL::CACHING-DFUN-COST PCL::*SLOT-VECTOR-SYMBOLS*
+   COMMON-LISP::SIGNED-BYTE PCL::ECD-SOURCE PCL::WRAPPER-LAYOUT
+   PCL::SI-SLOT-NAMES PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OPTIONS)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHODS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DECLARATIONS)|
+   PCL::|(FAST-WRITER-METHOD GENERIC-FUNCTION INITIAL-METHODS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITIAL-METHODS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
+   PCL::|(FAST-WRITER-METHOD SLOT-CLASS DIRECT-SLOTS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-CLASS SLOTS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOTS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-METHODS)|
+   PCL::OLD-SLOTS
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT RECOMP-REASONS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SLOT-DESCRIPTIONS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::CONSTRUCTORS)|
+   COMMON-LISP::OPEN
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::NO-EMIT)|
+   COMMON-LISP::DISASSEMBLE S::C-OCOMPLEX-REAL PCL::WRAPPER-2
+   PCL::GET-CACHE-VECTOR-LOCK-COUNT PCL::GET-SLOTS PCL::NEW-SLOTS
+   PCL::|FAST-INSTANCE-BOUNDP SLOT0| COMMON-LISP::CONTINUE
+   COMMON-LISP::TAN S::C-SET-HASHTABLE-RHSIZE S::C-SET-HASHTABLE-SIZE
+   PCL::WRAPPER-0 PCL::||)
+ "PCL")
+
+(lisp::in-package "SI")
+(export '(%structure-name
+          %compiled-function-name
+          %set-compiled-function-name))
+(in-package "PCL")
--- gcl27-2.7.0.orig/pcl/sys-proclaim.lisp
+++ gcl27-2.7.0/pcl/sys-proclaim.lisp
@@ -0,0 +1,3388 @@
+
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ACCESSOR-DFUN-INFO)) (T))
+   PCL::ACCESSOR-DFUN-INFO-CACHE PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::DEFAULT-METHOD-ONLY-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-MISS PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
+   ITERATE::OPTIMIZE-ITERATE-FORM ITERATE::SIMPLE-EXPAND-GATHERING-FORM
+   ITERATE::RENAME-AND-CAPTURE-VARIABLES PCL::MAKE-METHOD-SPEC
+   PCL::EXPAND-DEFGENERIC PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
+   PCL::FIRST-FORM-TO-LISP PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
+   PCL::EMIT-BOUNDP-CHECK PCL::MAKE-TOP-LEVEL-FORM
+   PCL::EMIT-SLOT-READ-FORM PCL::EMIT-1-T-DLAP PCL::MAKE-DFUN-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (T))
+   PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
+   PCL::LOAD-DEFCLASS PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION
+   PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+   PCL::REAL-LOAD-DEFCLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T)) (VALUES &REST T))
+   WALKER::WALK-TEMPLATE-HANDLE-REPEAT PCL::WALK-METHOD-LAMBDA
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
+   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+   PCL::MAKE-METHOD-INITARGS-FORM
+   PCL::|(FAST-METHOD NO-NEXT-METHOD (STANDARD-GENERIC-FUNCTION STANDARD-METHOD))|
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STANDARD-OBJECT))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::CPD-COUNT)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 7)) PCL::CACHE-FIELD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 255))
+   PCL::CACHE-NKEYS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::CACHE-VALUEP)) 
+(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|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::ONE-CLASS-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::PV-TABLE)) PCL::MAKE-PV-TABLE
+   PCL::|__si::MAKE-PV-TABLE|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T)) (OR (MEMBER PCL::READER PCL::WRITER BOUNDP) (MEMBER NIL)))
+   PCL::UPDATE-GF-INFO PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::CHECKING))
+   PCL::|__si::MAKE-CHECKING|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (NULL)) PCL::FIX-EARLY-GENERIC-FUNCTIONS
+   PCL::FALSE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|)) 
+(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 ((STRUCTURE PCL::CACHE)) (SIMPLE-ARRAY T (*)))
+   PCL::CACHE-VECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-CONSTANT-VALUE-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   WALKER::VARIABLE-SYMBOL-MACRO-P PCL::REMTAIL PCL::%SET-CCLOSURE
+   PCL::MAKE-DLAP-LAMBDA-LIST PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST
+   PCL::MAKE-DFUN-LAMBDA-LIST PCL::MAKE-PLIST PCL::DEFAULT-INITARGS-1
+   PCL::MEC-ALL-CLASSES PCL::DESTRUCTURE-INTERNAL
+   PCL::CLASS-CAN-PRECEDE-P WALKER:VARIABLE-LEXICAL-P
+   PCL::MEC-ALL-CLASS-LISTS PCL::NET-CONSTANT-CONVERTER
+   PCL::MEMF-CONSTANT-CONVERTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (T)) SETF::|PCL::PLIST-VALUE|
+   SETF::|PCL::METHOD-FUNCTION-GET| WALKER::WALK-DO* WALKER::WALK-IF
+   WALKER::WALK-LAMBDA WALKER::WALK-COMPILER-LET
+   WALKER::RELIST-INTERNAL WALKER::WALK-SETQ WALKER::WALK-LET
+   WALKER::WALK-MULTIPLE-VALUE-BIND WALKER::WALK-LET*
+   WALKER::WALK-SYMBOL-MACROLET WALKER::WALK-PROG WALKER::WALK-PROG*
+   WALKER::WALK-DO WALKER::WALK-LOCALLY WALKER::WALK-MACROLET
+   WALKER::WALK-NAMED-LAMBDA WALKER::WALK-UNEXPECTED-DECLARE
+   PCL::CONVERT-TABLE PCL::OPTIMIZE-GF-CALL-INTERNAL
+   PCL::TRACE-EMF-CALL-INTERNAL PCL::SET-SLOT-VALUE
+   PCL::GET-FUNCTION-GENERATOR PCL::OBSOLETE-INSTANCE-TRAP
+   PCL::FLUSH-CACHE-TRAP PCL::SET-FUNCTION-NAME-1
+   PCL::SORT-APPLICABLE-METHODS PCL::DECLARE-STRUCTURE
+   PCL::INVALIDATE-WRAPPER
+   PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
+   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
+   PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
+   PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
+   PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
+   PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
+   PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
+   PCL::SET-SLOT-VALUE-NORMAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::DFUN-INFO))
+   PCL::|__si::MAKE-DFUN-INFO|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) &REST T) (T)) PCL::ADD-NAMED-METHOD
+   PCL::REAL-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FUNCTION-RETURNING-NIL))
+   PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (NOT (MEMBER NIL)))
+   PCL::PV-TABLE-LOOKUP-PV-ARGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (MEMBER AREF SVREF CHAR SCHAR BIT SBIT ELT))
+   ITERATE::SEQUENCE-ACCESSOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-INDEX))
+   PCL::|__si::MAKE-ONE-INDEX|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::FAST-METHOD-CALL)) (T))
+   PCL::FAST-METHOD-CALL-ARG-INFO
+   PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
+   PCL::FAST-METHOD-CALL-PV-CELL)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (VALUES (T) (T))) PCL::COMPUTE-CODE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES (T) (STRUCTURE PCL::CACHE) (STRUCTURE PCL::ONE-INDEX)))
+   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-TAGBODY WALKER::WALK-TAGBODY-1 WALKER::WALK-LABELS
+   WALKER::WALK-FLET WALKER::RECONS WALKER:VARIABLE-DECLARATION
+   PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))| 
+   PCL::CAN-OPTIMIZE-ACCESS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (OR
+     (OR
+      (MEMBER "is not a symbol and so cannot be bound")
+      (MEMBER "is a keyword and so cannot be bound")
+      (MEMBER "is a constant and so cannot be bound")
+      (MEMBER "cannot be bound"))
+     (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE))
+   PCL::|STRUCTURE-OBJECT class constructor|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (STRUCTURE PCL::CACHE))
+   PCL::COPY-CACHE-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (OR
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::CACHING))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-CACHING-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (STRUCTURE PCL::CHECKING))
+   PCL::COPY-CHECKING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ONE-CLASS)) (STRUCTURE PCL::ONE-CLASS))
+   PCL::COPY-ONE-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (VALUES (T) (T) (T)))
+   PCL::PARSE-METHOD-OR-SPEC)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (INTEGER 0 268435454))
+   PCL::BOOTSTRAP-SLOT-INDEX)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM
+   PCL::MAKE-DEFMETHOD-FORM-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-WRAPPER))
+   PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CONSTANT-VALUE)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::COPY-CONSTANT-VALUE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (NULL))
+   WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
+   PCL::RESET-CLASS-INITIALIZE-INFO PCL::UPDATE-GFS-OF-CLASS
+   PCL::FREE-CACHE PCL::DO-STANDARD-DEFSETF-1
+   PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS PCL::BOOTSTRAP-CLASS-PREDICATES
+   PCL::FUNCTION-RETURNING-NIL PCL::UPDATE-PV-TABLE-CACHE-INFO
+   PCL::FREE-CACHE-VECTOR PCL::COMPUTE-STD-CPL-PHASE-2
+   PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES
+   PCL::GET-MAKE-INSTANCE-FUNCTIONS PCL::FUNCTION-PRETTY-ARGLIST
+   PCL::RESET-CLASS-INITIALIZE-INFO-1
+   PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS
+   PCL::UPDATE-CLASS-CAN-PRECEDE-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((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
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::COPY-FAST-INSTANCE-BOUNDP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO)) (T))
+   PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::ONE-INDEX-DFUN-INFO-INDEX
+   PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::OPTIMIZE-INSTANCE-ACCESS)) 
+(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 (&REST T) (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::MAKE-FAST-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (OR
+       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)
+       (STRUCTURE PCL::CHECKING) (STRUCTURE PCL::DEFAULT-METHOD-ONLY)
+       (STRUCTURE PCL::NO-METHODS))
+      (MEMBER NIL))))
+   PCL::MAKE-FINAL-DFUN-INTERNAL)) 
+(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) &REST T) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::INITIAL)) (T)) PCL::INITIAL-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::TWO-CLASS-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (OR
+     (SIMPLE-ARRAY FIXNUM 1) (SIMPLE-ARRAY T 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-INT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT 1)
+     (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR 1) (SIMPLE-ARRAY BIT 1)
+     (SIMPLE-ARRAY NIL 1) (SYSTEM:PROPER-CONS (T) (T))
+     (SIMPLE-ARRAY CHARACTER 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR 1)
+     (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR 1)
+     (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT 1)
+     (SIMPLE-ARRAY SHORT-FLOAT 1) (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT 1)
+     (SIMPLE-ARRAY LONG-FLOAT 1)
+     (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM 1) (MEMBER NIL)))
+   PCL::EARLY-COLLECT-DEFAULT-INITARGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (STRUCTURE) (T)) NIL)
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (STRUCTURE-OBJECT))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::CHECKING))
+   PCL::CHECKING-DFUN-INFO)) 
+(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)) (SIMPLE-ARRAY T (6)))
+   PCL::MAKE-FGEN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPILE-LAMBDA)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) &REST T) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::FILL-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (SYSTEM:STD-INSTANCE))
+   PCL::COPY-STD-INSTANCE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::NO-METHODS)) (T)) PCL::NO-METHODS-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM)))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (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)) 
+(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))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHE)) PCL::COPY-CACHE
+   PCL::CHECK-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
+   PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P PCL::*TYPEP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (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) (T) (T))
+    (VALUES &OPTIONAL (T) (T) (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
+   PCL::CACHE-MISS-VALUES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) NIL) PCL::NO-SLOT PCL::CPL-INCONSISTENT-ERROR
+   PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:HASH-TABLE-EQUALP) (SYSTEM:HASH-TABLE-EQL)
+      (SYSTEM:HASH-TABLE-EQ) (SYSTEM:HASH-TABLE-EQUAL) (MEMBER NIL))
+     (T) (T) (T) (OR (INTEGER 0 9223372036854775807) (MEMBER NIL))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::MAKE-ACCESSOR-TABLE)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (STRUCTURE PCL::N-N)) PCL::N-N-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::TWO-CLASS))
+   PCL::|__si::MAKE-TWO-CLASS|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (VALUES (T) (NULL) (STRUCTURE PCL::ONE-CLASS)))
+   PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (T)) SETF::|PCL::INITIALIZE-INFO SLOT5|
+   SETF::|PCL::SYSTEM:S-DATA SLOT3| SETF::|PCL::GDEFINITION|
+   SETF::|PCL::ONE-INDEX-DFUN-INFO SLOT2| SETF::|PCL::ARG-INFO SLOT5|
+   SETF::|PCL::FAST-METHOD-CALL SLOT2|
+   SETF::|PCL::CLASS-DEFSTRUCT-CONSTRUCTOR| SETF::|PCL::PV-TABLE SLOT1|
+   SETF::|PCL::MODULE SLOT2| SETF::|PCL::CACHE SLOT7|
+   SETF::|PCL::COMPILER::FN SLOT2| SETF::|PCL::SYSTEM:S-DATA SLOT13|
+   SETF::|PCL::SLOT-DEFINITION-LOCATION|
+   SETF::|PCL::SLOT-DEFINITION-READER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-WRITER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-BOUNDP-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION|
+   SETF::|PCL::SLOT-DEFINITION-ALLOCATION|
+   SETF::|PCL::SLOT-DEFINITION-INITFUNCTION|
+   SETF::|PCL::INITIALIZE-INFO SLOT3| SETF::|PCL::SYSTEM:S-DATA SLOT1|
+   SETF::|PCL::GF-PRETTY-ARGLIST| SETF::|PCL::ARG-INFO SLOT3|
+   SETF::|PCL::FAST-METHOD-CALL SLOT0|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT3|
+   SETF::|PCL::INITIALIZE-INFO SLOT13| SETF::|PCL::MODULE SLOT0|
+   SETF::|PCL::CACHE SLOT5| SETF::|PCL::COMPILER::FN SLOT0|
+   SETF::|PCL::SYSTEM:S-DATA SLOT11|
+   SETF::|PCL::SLOT-DEFINITION-INITFORM|
+   SETF::|PCL::INITIALIZE-INFO SLOT1| SETF::|PCL::ARG-INFO SLOT1|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT1|
+   SETF::|PCL::OBJECT-PLIST| SETF::|PCL::SYSTEM:S-DATA SLOT8|
+   SETF::|PCL::INITIALIZE-INFO SLOT11| SETF::|PCL::CACHE SLOT3|
+   SETF::|PCL::GENERIC-FUNCTION-METHOD-CLASS|
+   SETF::|PCL::ACCESSOR-DFUN-INFO SLOT1|
+   SETF::|PCL::FIND-CLASS-PREDICATE| SETF::|PCL::GENERIC-FUNCTION-NAME|
+   SETF::|PCL::COMPILER::FN SLOT7| SETF::|PCL::METHOD-CALL SLOT1|
+   SETF::|PCL::FAST-INSTANCE-BOUNDP SLOT0|
+   SETF::|PCL::INITIALIZE-INFO SLOT8| SETF::|PCL::SYSTEM:S-DATA SLOT6|
+   SETF::|PCL::CACHE SLOT1| SETF::|PCL::ARG-INFO SLOT8|
+   SETF::|PCL::SLOT-DEFINITION-TYPE|
+   SETF::|PCL::SLOT-DEFINITION-READERS|
+   SETF::|PCL::SLOT-DEFINITION-WRITERS|
+   SETF::|PCL::SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL|
+   SETF::|PCL::COMPILER::FN SLOT5| SETF::|PCL::SYSTEM:S-DATA SLOT16|
+   SETF::|PCL::CACHE SLOT11| SETF::|PCL::CHECKING SLOT1|
+   SETF::|PCL::INITIALIZE-INFO SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT4|
+   SETF::|PCL::ARG-INFO SLOT6| SETF::|PCL::FAST-METHOD-CALL SLOT3|
+   SETF::|PCL::PV-TABLE SLOT2| SETF::|PCL::MODULE SLOT3|
+   SETF::|PCL::CACHE SLOT8| SETF::|PCL::COMPILER::FN SLOT3|
+   SETF::|PCL::SYSTEM:S-DATA SLOT14| SETF::|PCL::INITIALIZE-INFO SLOT4|
+   SETF::|PCL::SYSTEM:S-DATA SLOT2| SETF::|PCL::TWO-CLASS SLOT4|
+   SETF::|PCL::CLASS-DIRECT-SLOTS| SETF::|PCL::CLASS-SLOTS|
+   SETF::|PCL::ONE-CLASS SLOT3| SETF::|PCL::METHOD-GENERIC-FUNCTION|
+   SETF::|PCL::ARG-INFO SLOT4| SETF::|PCL::FAST-METHOD-CALL SLOT1|
+   SETF::|COMMON-LISP::CLASS-NAME|
+   SETF::|PCL::GENERIC-FUNCTION-METHOD-COMBINATION|
+   SETF::|PCL::PV-TABLE SLOT0| SETF::|PCL::MODULE SLOT1|
+   SETF::|PCL::CACHE SLOT6| SETF::|PCL::COMPILER::FN SLOT1|
+   SETF::|PCL::SYSTEM:S-DATA SLOT12| SETF::|PCL::CLASS-DEFSTRUCT-FORM|
+   SETF::|PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST|
+   SETF::|PCL::INITIALIZE-INFO SLOT2|
+   SETF::|PCL::SLOT-DEFINITION-INITARGS|
+   SETF::|PCL::SYSTEM:S-DATA SLOT0| SETF::|PCL::ARG-INFO SLOT2|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT2|
+   SETF::|PCL::SYSTEM:S-DATA SLOT9| SETF::|PCL::INITIALIZE-INFO SLOT12|
+   SETF::|PCL::CACHE SLOT4| SETF::|PCL::METHOD-FUNCTION-PLIST|
+   SETF::|PCL::SYSTEM:S-DATA SLOT10| SETF::|PCL::INITIALIZE-INFO SLOT0|
+   SETF::|PCL::SLOT-DEFINITION-CLASS| SETF::|PCL::COMPILER::FN SLOT8|
+   SETF::|PCL::ARG-INFO SLOT0| SETF::|PCL::SLOT-DEFINITION-NAME|
+   SETF::|PCL::INITIALIZE-INFO SLOT9|
+   SETF::|PCL::CLASS-PRECEDENCE-DESCRIPTION SLOT0|
+   SETF::|PCL::SYSTEM:S-DATA SLOT7| SETF::|PCL::INITIALIZE-INFO SLOT10|
+   SETF::|PCL::CACHE SLOT2| SETF::|PCL::ARG-INFO SLOT9|
+   SETF::|PCL::ARG-INFO SLOT10|
+   SETF::|PCL::GENERIC-FUNCTION-INITIAL-METHODS|
+   SETF::|PCL::GENERIC-FUNCTION-METHODS|
+   SETF::|PCL::COMPILER::FN SLOT6| SETF::|PCL::SYSTEM:S-DATA SLOT17|
+   SETF::|PCL::METHOD-CALL SLOT0| SETF::|PCL::INITIALIZE-INFO SLOT7|
+   SETF::|PCL::SYSTEM:S-DATA SLOT5| SETF::|PCL::CACHE SLOT0|
+   SETF::|PCL::ARG-INFO SLOT7| SETF::|PCL::CLASS-INITIALIZE-INFO|
+   SETF::|PCL::GF-DFUN-STATE| SETF::|PCL::PV-TABLE SLOT3|
+   SETF::|PCL::MODULE SLOT4| SETF::|PCL::CACHE SLOT9|
+   SETF::|PCL::COMPILER::FN SLOT4| SETF::|PCL::SYSTEM:S-DATA SLOT15|
+   SETF::|PCL::CACHE SLOT10| SETF::|PCL::DFUN-INFO SLOT0|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot WRITER|
+   WALKER::ENVIRONMENT-FUNCTION WALKER::ENVIRONMENT-MACRO
+   ITERATE::MV-SETQ SLOT-BOUNDP
+   PCL:FUNCALLABLE-STANDARD-INSTANCE-ACCESS SLOT-MAKUNBOUND
+   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::VARIABLE-CLASS
+   PCL::COMPUTE-APPLICABLE-KEYWORDS PCL::COMPUTE-CONSTANTS
+   PCL::FDEFINE-CAREFULLY PCL::SET-INITIAL-METHODS
+   PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P PCL::PROCLAIM-DEFMETHOD
+   PCL::DESCRIBE-PACKAGE PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER
+   PCL::%CCLOSURE-ENV-NTHCDR PCL::MAP-PV-TABLE-REFERENCES-OF
+   PCL::AUGMENT-TYPE PCL::GET-KEY-ARG-TAIL PCL::VALUE-FOR-CACHING
+   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::REAL-REMOVE-METHOD
+   PCL::SET-METHODS PCL::SET-STRUCTURE-SVUC-METHOD PCL::COMPUTE-PV
+   PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION
+   PCL::SWAP-WRAPPERS-AND-SLOTS PCL::REDIRECT-EARLY-FUNCTION-INTERNAL
+   WALKER:VARIABLE-SPECIAL-P PCL::LEGAL-LAMBDA-LIST-P
+   PCL::FIND-STANDARD-II-METHOD PCL::SLOT-BOUNDP-NORMAL
+   PCL::SET-STANDARD-SVUC-METHOD PCL::PROCLAIM-DEFGENERIC
+   PCL::SET-WRAPPER PCL::ADD-FORMS PCL::MAKE-CLASS-PREDICATE
+   PCL::UPDATE-INITS PCL::REDEFINE-FUNCTION
+   PCL::SET-FUNCTION-PRETTY-ARGLIST PCL::PRINTING-RANDOM-THING-INTERNAL
+   PCL::SLOT-UNBOUND-INTERNAL PCL::PLIST-VALUE PCL::MAKE-CDXR
+   PCL::FIND-SLOT-DEFINITION PCL::SET-FUNCTION-NAME)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (INTEGER -9223372036854775808 9223372036854775807))
+    (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::COMPUTE-STD-CPL-PHASE-3)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (SYSTEM:TRUE)) PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (VALUES))
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (VALUES &REST T))
+   ITERATE::ITERATE-TRANSFORM-BODY
+   PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (T)) PCL::PV-WRAPPERS-FROM-PV-ARGS
+   PCL::UNTRACE-METHOD PCL::INTERN-PV-TABLE PCL::LOAD-TRUENAME)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (NOT (MEMBER NIL))) PCL::EARLY-CLASS-DEFINITION
+   PCL::GET-PV-CELL-FOR-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (VALUES &REST T)) ENSURE-GENERIC-FUNCTION
+   MAKE-INSTANCE REINITIALIZE-INSTANCE INITIALIZE-INSTANCE
+   ALLOCATE-INSTANCE PCL:ENSURE-CLASS MAKE-LOAD-FORM
+   PCL::CALL-NO-NEXT-METHOD PCL::DISPATCH-DFUN-COST
+   PCL::NO-PRIMARY-METHOD PCL::MAKE-TYPE-PREDICATE-NAME
+   WALKER:WALK-FORM PCL::MAKE-METHOD-FUNCTION-INTERNAL
+   PCL::MAKE-INSTANCE-1 PCL::COERCE-TO-CLASS
+   PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
+   PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T| 
+   PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST) T|
+   WALKER:MACROEXPAND-ALL
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION) T|
+   PCL::GET-DFUN-CONSTRUCTOR
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :NAME :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :INITFUNCTION :NAME :READERS :WRITERS :INITARGS :INITFORM) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :LAMBDA-LIST :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :FUNCTION :DEFINITION-SOURCE) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-EFFECTIVE-SLOT-DEFINITION (:DEFSTRUCT-ACCESSOR-SYMBOL :INTERNAL-READER-FUNCTION :INTERNAL-WRITER-FUNCTION :NAME :INITFORM :INITFUNCTION :INITARGS :ALLOCATION :TYPE :CLASS) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-DIRECT-SLOT-DEFINITION (:CLASS :NAME :DEFSTRUCT-ACCESSOR-SYMBOL :INTERNAL-READER-FUNCTION :INTERNAL-WRITER-FUNCTION :TYPE :INITFORM :INITFUNCTION) NIL|
+   PCL::|MAKE-INSTANCE STRUCTURE-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS :NAME) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-EFFECTIVE-SLOT-DEFINITION (:NAME :INITFORM :INITFUNCTION :INITARGS :ALLOCATION :TYPE :CLASS) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-DIRECT-SLOT-DEFINITION (:CLASS :NAME :READERS :WRITERS :INITARGS) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-CLASS (:NAME :DIRECT-SUPERCLASSES :DIRECT-SLOTS :DEFINITION-SOURCE :PREDICATE-NAME) NIL|
+   PCL::|MAKE-INSTANCE EQL-SPECIALIZER (:OBJECT) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :SPECIALIZERS :LAMBDA-LIST :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST) NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION NIL NIL|
+   PCL::|MAKE-INSTANCE STANDARD-GENERIC-FUNCTION (:METHOD-COMBINATION :METHOD-CLASS) NIL|
+   PCL::|MAKE-INSTANCE CLASS-EQ-SPECIALIZER (:CLASS) NIL|
+   PCL::GET-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+   PCL::MAKE-FAST-INSTANCE-BOUNDP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-ARGLIST PCL::CAN-OPTIMIZE-ACCESS1)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 0 268435454)) PCL::GF-LL-NOPT
+   PCL::GENERIC-FUNCTION-NREQ)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::ALLOCATE-STANDARD-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T) (T))
+    (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-GREATER-THAN-1-DLAP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::N-N)) (T)) PCL::N-N-CACHE
+   PCL::N-N-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::PV-TABLE)) (STRUCTURE PCL::PV-TABLE))
+   PCL::COPY-PV-TABLE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (T) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::ENSURE-CLASS-VALUES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     &OPTIONAL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (NULL)))
+   PCL::EMIT-READER/WRITER-FUNCTION
+   PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (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) (T))
+    (OR (SYSTEM:STD-INSTANCE) (SYSTEM:FUNCALLABLE-STD-INSTANCE)))
+   PCL::CHANGE-CLASS-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION PCL::MEMF-CODE-CONVERTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::COPY-ONE-INDEX)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::CACHE)) PCL::MAP-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (MEMBER #())) PCL::COMPUTE-CALLS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO1)) 
+(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
+    ((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
+    ((STRUCTURE PCL::FAST-INSTANCE-BOUNDP))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::CACHES-TO-ALLOCATE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::DISPATCH)) PCL::DISPATCH-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (NULL)) PCL::RECORD-DEFINITION
+   PCL::NAMED-OBJECT-PRINT-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
+   PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
+   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) &REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::CAPITALIZE-WORDS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-FETCH-WRAPPER PCL::MAKE-EMF-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) NIL) WALKER::UNBOUND-LEXICAL-FUNCTION
+   PCL::CALLED-FIN-WITHOUT-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T))
+    (NULL))
+   PCL::%CHECK-CNM-ARGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (STRUCTURE PCL::ARG-INFO)))
+   PCL::TYPES-FROM-ARGUMENTS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (T))
+   PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+(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 ((SYSTEM:STD-INSTANCE) (T)) (T))
+   PCL:STANDARD-INSTANCE-ACCESS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (SIMPLE-ARRAY CHARACTER (*)))
+   PCL::STRING-APPEND)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER :INSTANCE))
+   PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|)) 
+(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::INITIALIZE-INFO))
+   PCL::MAKE-INITIALIZE-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (INTEGER 0 9223372036854775807) &REST T)
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE-FROM-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((INTEGER 1 9223372036854775807)) (INTEGER 1 4611686018427387904))
+   PCL::POWER-OF-TWO-CEILING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T)
+     (OR
+      (BROADCAST-STREAM) (CONCATENATED-STREAM) (ECHO-STREAM)
+      (OR
+       (SYSTEM:FILE-INPUT-STREAM) (SYSTEM:FILE-OUTPUT-STREAM)
+       (SYSTEM:FILE-IO-STREAM) (SYSTEM:FILE-PROBE-STREAM))
+      (OR (SYSTEM:STRING-INPUT-STREAM) (SYSTEM:STRING-OUTPUT-STREAM))
+      (OR
+       (SYSTEM::FILE-SYNONYM-STREAM) (SYSTEM::NON-FILE-SYNONYM-STREAM))
+      (TWO-WAY-STREAM))
+     (T))
+    (NULL))
+   PCL::PRINT-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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) &REST T) (T)) SETF::|COMMON-LISP::FIND-CLASS|
+   WALKER::CONVERT-MACRO-TO-LAMBDA PCL::MAKE-EMF-FROM-METHOD
+   PCL::PROBE-CACHE PCL::GET-EFFECTIVE-METHOD-FUNCTION1
+   PCL::GET-METHOD-FUNCTION-PV-CELL
+   PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::METHOD-FUNCTION-GET
+   PCL::REAL-ADD-METHOD PCL::GET-DECLARATION
+   PCL::FIND-CLASS-PREDICATE-FROM-CELL PCL::FIND-CLASS-FROM-CELL
+   PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
+   PCL::REAL-ENSURE-GF-USING-CLASS--NULL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (NULL)) ITERATE::MAYBE-WARN
+   PCL::INITIALIZE-INTERNAL-SLOT-GFS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES (OR (SYSTEM:TRUE) (NULL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-AND)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::N-N)) PCL::|__si::MAKE-N-N|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) (T))
+   PCL::LOAD-DEFMETHOD-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 1 256))
+   PCL::CACHE-LINE-SIZE)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::MAKE-CPD)) 
+(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) &REST T) (T)) WALKER::RELIST WALKER::RELIST*
+   FIND-CLASS PCL::ALLOCATE-STRUCTURE-INSTANCE
+   PCL::ALLOCATE-STANDARD-INSTANCE PCL::EARLY-FIND-CLASS-SYMBOL
+   PCL::INITIALIZE-METHOD-FUNCTION PCL::MAKE-FINAL-DFUN
+   PCL::MAKE-SPECIALIZABLE PCL::FIND-CLASS-CELL
+   PCL::FIND-CLASS-PREDICATE PCL::UPDATE-DFUN PCL::TRACE-METHOD
+   PCL::SET-DFUN PCL::EARLY-METHOD-SPECIALIZERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (T)) WALKER::WALK-PROG/PROG*
+   WALKER::WALK-DO/DO* WALKER::WALK-LET/LET* PCL::BOOTSTRAP-SET-SLOT
+   PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
+   PCL::GET-WRAPPERS-FROM-CLASSES PCL::FROB-COMBINED-METHOD-ARGS
+   PCL::LOAD-LONG-DEFCOMBIN
+   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::MEMF-TEST-CONVERTER
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE PCL::OPTIMIZE-WRITER
+   PCL::OPTIMIZE-READER PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
+   PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|
+   PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
+   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
+   PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+   PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+   PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
+   PCL::LOAD-SHORT-DEFCOMBIN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (INTEGER 0 9223372036854775807))
+    (STRUCTURE PCL::CACHE))
+   PCL::GET-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (NULL))
+   PCL::MAP-SPECIALIZERS PCL::MAP-ALL-GENERIC-FUNCTIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (T)) PCL::DISPATCH-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+    (STRUCTURE PCL::DEFAULT-METHOD-ONLY))
+   PCL::COPY-DEFAULT-METHOD-ONLY)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) &REST T) (T))
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
+(PROCLAIM '(FTYPE (FUNCTION ((T) (T) &REST T) NIL) PCL::CPL-ERROR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (VALUES
+     (SYSTEM:PROPER-CONS (T) (T))
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::ADD-METHOD-DECLARATIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (SYSTEM:TRUE)) PCL::SLOT-OBJECT-SIMPLE-TYPEP-FN
+   PCL::STRUCTURE-SLOT-BOUNDP PCL::FUNCTION-RETURNING-T)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-DEFAULT-ONLY)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (INTEGER 0 9223372036854775807))
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::FILL-CACHE-FROM-CACHE-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::INITIAL-DISPATCH))
+    (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::COPY-INITIAL-DISPATCH)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (INTEGER 0 268435455)) PCL::ADD-TO-CVECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::RESET-INITIALIZE-INFO)) 
+(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) (T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
+   PCL::GET-ACCESSOR-METHOD-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::PV-TABLE-SLOT-NAME-LISTS PCL::PV-TABLE-CALL-LIST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::UPDATE-INITIALIZE-INFO-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (VALUES
+     (T)
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))))
+   PCL::MAKE-DEFAULT-INITARGS-FORM-LIST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::|__si::MAKE-ARG-INFO|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (NULL)) PCL::CHECK-APPLICABLE-KEYWORDS
+   PCL::ADD-SLOT-ACCESSORS PCL::REMOVE-SLOT-ACCESSORS
+   PCL::ADD-DIRECT-SUBCLASSES PCL::REMOVE-DIRECT-SUBCLASSES
+   PCL::METHOD-FUNCTION-RETURNING-NIL PCL::UPDATE-ALL-PV-TABLE-CACHES
+   PCL::UPDATE-CPL PCL::UPDATE-SLOTS PCL::UPDATE-CLASS
+   PCL::UPDATE-STD-OR-STR-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (OR
+     (MEMBER "is neither a class object nor an eql specializer")
+     (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (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))
+    (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))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   PCL::SPLIT-DECLARATIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T)) (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::KEY-NAMES)) 
+(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))
+    (OR
+     (SIMPLE-ARRAY CHARACTER (*))
+     (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)))
+   PCL::SYMBOL-PKG-NAME)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL)))
+    (VALUES
+     (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))))
+   PCL::PARSE-DEFMETHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (VALUES &REST T))
+   SETF::|PCL::SLOT-VALUE-USING-CLASS| WALKER::WALK-TEMPLATE
+   PCL:MAKE-METHOD-LAMBDA PCL::GENERATE-DISCRIMINATION-NET
+   PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION PCL::INVALID-QUALIFIERS
+   PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|
+   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
+   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+   PCL::SET-CLASS-SLOT-VALUE-1 PCL::ACCESSOR-MISS
+   PCL::%INVALID-QUALIFIERS PCL::BOOTSTRAP-ACCESSOR-DEFINITION
+   PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
+   PCL::|(FAST-METHOD NO-PRIMARY-METHOD (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
+   PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
+   PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
+   PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CACHING PCL::EMIT-CHECKING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     &REST T)
+    (VALUES &REST T))
+   PCL::MAP-ALL-CLASSES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (NULL))
+   PCL::MAP-ALL-ORDERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    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::METHOD-CALL)) (T))
+   PCL::METHOD-CALL-CALL-METHOD-ARGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CACHING)) PCL::CACHING-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   PCL::PRECOMPUTE-EFFECTIVE-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (OR (MEMBER "is not a non-null atom") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (T))
+   PCL::SORT-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((INTEGER 0 7) (INTEGER 0 9223372036854775807) (T))
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::LIST-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) &REST T) (T))
+   PCL::LOAD-DEFMETHOD)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHING)) (T)) PCL::CACHING-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-DEFMETHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DFUN-INFO)) (T)) PCL::DFUN-INFO-CACHE)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((STRUCTURE PCL::CACHE)) (T)) PCL::CACHE-OWNER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (VALUES (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::COMPUTE-APPLICABLE-METHODS-EMF)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::CONSTANT-VALUE-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::INITIALIZE-INSTANCE-SIMPLE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-DEFAULT-ONLY-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (SYSTEM:TRUE) (NULL))) PCL::EARLY-GF-P
+   PCL::METHOD-CALL-P PCL::ONE-INDEX-P PCL::STD-INSTANCE-P PCL::N-N-P
+   PCL::LEGAL-CLASS-NAME-P PCL::TWO-CLASS-P PCL::INITIALIZE-INFO-P
+   PCL::ONE-CLASS-P PCL::DISPATCH-P PCL::DEFAULT-STRUCTUREP
+   PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::DEFAULT-CONSTANTP
+   PCL::DEFAULT-STRUCTURE-INSTANCE-P PCL::STRUCTURE-TYPE-P
+   PCL::NO-METHODS-P PCL::CONSTANT-VALUE-P
+   PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P PCL::CACHING-P PCL::GBOUNDP
+   PCL::INITIAL-P PCL::DNET-METHODS-P PCL::FAST-METHOD-CALL-P
+   PCL::CCLOSUREP PCL::EARLY-METHOD-STANDARD-ACCESSOR-P
+   PCL::FUNCALLABLE-INSTANCE-P PCL::FIELD-TYPE-SIMPLE-TYPEP-FN
+   PCL::ONE-INDEX-DFUN-INFO-P PCL::UPDATE-C-A-M-GF-INFO PCL::CHECKING-P
+   PCL::COMPLICATED-INSTANCE-CREATION-METHOD PCL::INITIAL-DISPATCH-P
+   PCL::ARG-INFO-P PCL::DEFAULT-METHOD-ONLY-P PCL::STRUCTURE-OBJECT-P
+   PCL::PV-TABLEP PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS PCL::CACHE-P
+   PCL::%FBOUNDP PCL::STRUCTURE-INSTANCE-P
+   PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::ACCESSOR-DFUN-INFO-P
+   PCL::ARG-INFO-VALID-P PCL::FAST-INSTANCE-BOUNDP-P PCL::DFUN-INFO-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::DISPATCH))
+   PCL::|__si::MAKE-DISPATCH|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (INTEGER -9223372036854775808 9223372036854775807))
+   PCL::PV-TABLE-PV-SIZE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION))
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (VALUES &REST T))
+   PCL::GENERATE-DISCRIMINATION-NET-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (OR (OR (SYSTEM:TRUE) (NULL)) (KEYWORD) (SYSTEM:GSYM))
+     (T))
+    (VALUES &REST T))
+   PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|)) 
+(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)) 
+(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 (&REST T) (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::NET-CODE-CONVERTER PCL::DEFAULT-CODE-CONVERTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T)) (VALUES (T) (T) (T) (T)))
+   PCL::CACHE-MISS-VALUES-INTERNAL)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T)) (OR (MEMBER NIL) (INTEGER 0 268435455) (MEMBER T)))
+   PCL::SYMBOL-OR-CONS-LESSP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     &OPTIONAL (T) (T) (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   ITERATE::EXPAND-INTO-LET)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EXPAND-SHORT-DEFCOMBIN PCL::EXPAND-LONG-DEFCOMBIN
+   PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST PCL::GET-SETF-FUNCTION-NAME
+   PCL::MAKE-PV-TYPE-DECLARATION PCL::COMPUTE-MCASE-PARAMETERS
+   PCL::MAKE-PV-TABLE-TYPE-DECLARATION PCL::MAKE-CALL-METHODS
+   PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD
+   PCL::MAKE-CALLS-TYPE-DECLARATION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (VALUES
+     &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T) (T)
+     (T)))
+   PCL::PARSE-METHOD-GROUP-SPECIFIER)) 
+(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)) (OR (INTEGER 1 268435454) (MEMBER NIL)))
+   PCL::NEXT-WRAPPER-FIELD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (VALUES &OPTIONAL (T) (T)))
+   PCL::ACCESSOR-VALUES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::INITIALIZE-INFO))
+    (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::COPY-INITIALIZE-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (OR (SYSTEM:TRUE) (NULL)))
+   ITERATE::VARIABLE-SAME-P PCL::SKIP-FAST-SLOT-ACCESS-P
+   PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P PCL::ENTRY-IN-CACHE-P
+   PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|)) 
+(PROCLAIM '(FTYPE (FUNCTION (&REST T) (INTEGER 0 0)) PCL::ZERO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (STRUCTURE PCL::ARG-INFO))
+   PCL::COPY-ARG-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
+   PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
+   PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::INITIAL)) (STRUCTURE PCL::INITIAL))
+   PCL::COPY-INITIAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::N-N)) (STRUCTURE PCL::N-N))
+   PCL::COPY-N-N)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::ARG-INFO)) PCL::MAKE-ARG-INFO)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::MUTATE-SLOTS-AND-CALLS PCL::SLOT-NAME-LISTS-FROM-SLOTS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::FORM-LIST-TO-LISP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (OR
+     (OR
+      (OR (INTEGER * *) (RATIO * *))
+      (OR (SHORT-FLOAT * *) (LONG-FLOAT * *)))
+     (OR
+      (SYSTEM:COMPLEX* (INTEGER * *) (RATIO * *))
+      (SYSTEM:COMPLEX* (RATIO * *) (INTEGER * *))
+      (SYSTEM:COMPLEX* (INTEGER * *) (INTEGER * *))
+      (SYSTEM:COMPLEX* (RATIO * *) (RATIO * *))
+      (SYSTEM:COMPLEX* (SHORT-FLOAT * *) (SHORT-FLOAT * *))
+      (SYSTEM:COMPLEX* (LONG-FLOAT * *) (LONG-FLOAT * *)))))
+   PCL::CACHING-DFUN-COST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (STRUCTURE PCL::PV-TABLE))
+   PCL::MAKE-PV-TABLE-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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHING)) (STRUCTURE PCL::CACHING))
+   PCL::COPY-CACHING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-CHECKING-OR-CACHING)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::FAST-METHOD-CALL))
+    (STRUCTURE PCL::FAST-METHOD-CALL))
+   PCL::COPY-FAST-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 0 268435455)) PCL::EARLY-CLASS-SIZE
+   PCL::ARG-INFO-NKEYS PCL::ARG-INFO-NUMBER-REQUIRED)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (VALUES &OPTIONAL (NOT (MEMBER NIL)) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-CONSTANT-VALUE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (OR (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::PARSE-QUALIFIER-PATTERN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DEFAULT-METHOD-ONLY)) (T))
+   PCL::DEFAULT-METHOD-ONLY-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::MAKE-EARLY-GF)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION NIL (STRUCTURE PCL::CACHE)) PCL::MAKE-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (MEMBER PCL::READER PCL::WRITER) (MEMBER NIL)))
+   PCL::FINAL-ACCESSOR-DFUN-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (STRUCTURE PCL::ARG-INFO))
+   PCL::SET-ARG-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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) &REST T) (SIMPLE-ARRAY T (13))) PCL::MAKE-WRAPPER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (OR
+     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+     (MEMBER T)))
+   PCL::OPTIMIZE-SLOT-BOUNDP PCL::OPTIMIZE-SLOT-VALUE
+   PCL::OPTIMIZE-SET-SLOT-VALUE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ARG-INFO)) (T))
+   PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE
+   PCL::GF-INFO-C-A-M-EMF-STD-P PCL::ARG-INFO-LAMBDA-LIST
+   PCL::GF-INFO-FAST-MF-P PCL::GF-INFO-STATIC-C-A-M-EMF
+   PCL::ARG-INFO-NUMBER-OPTIONAL PCL::ARG-INFO-METATYPES
+   PCL::ARG-INFO-KEYWORDS PCL::ARG-INFO-PRECEDENCE
+   PCL::ARG-INFO-KEY/REST-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (VALUES &REST T))
+   SETF::|PCL::SLOT-ACCESSOR-STD-P| SETF::|PCL::SLOT-ACCESSOR-FUNCTION|
+   SETF::|PCL::CLASS-SLOT-VALUE| SETF::|COMMON-LISP::DOCUMENTATION|
+   WALKER::WALK-LET-IF WALKER::WALK-FORM-INTERNAL
+   WALKER::WALK-MULTIPLE-VALUE-SETQ ITERATE::WALK-GATHERING-BODY
+   ITERATE::RENAME-VARIABLES PCL:FIND-METHOD-COMBINATION
+   PCL:SLOT-MAKUNBOUND-USING-CLASS PCL:COMPUTE-EFFECTIVE-METHOD
+   PCL:SLOT-BOUNDP-USING-CLASS PCL:SLOT-VALUE-USING-CLASS
+   PCL::COMPUTE-SLOT-ACCESSOR-INFO PCL::CONSTANT-VALUE-MISS
+   PCL::GET-CLASS-SLOT-VALUE-1 PCL::CHECKING-MISS
+   PCL::ADD-WRITER-METHOD PCL::CONVERT-METHODS
+   PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P
+   PCL::SLOT-BOUNDP-USING-CLASS-DFUN PCL::ADD-BOUNDP-METHOD
+   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
+   PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
+   PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
+   PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
+   PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
+   PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS
+   PCL::ADD-READER-METHOD PCL::PRINT-STD-INSTANCE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::CONSTANT-VALUE))
+   PCL::|__si::MAKE-CONSTANT-VALUE|)) 
+(PROCLAIM '(FTYPE (FUNCTION NIL (VALUES)) PCL::COUNT-ALL-DFUNS)) 
+(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) (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::GENERATING-LISP
+   PCL::EMIT-READER/WRITER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T) (VALUES (T) (OR (SYSTEM:TRUE) (NULL)) (T) (T)))
+   PCL::GET-METHOD-FUNCTION)) 
+(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) (T) (T) (T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-DLAP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CHECKING)) (T)) PCL::CHECKING-CACHE
+   PCL::CHECKING-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T)) (OR (SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY T *)))
+   PCL::ALLOCATE-CACHE-VECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 1 4611686018427387904))
+   PCL::COMPUTE-LINE-SIZE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (STRUCTURE PCL::INITIALIZE-INFO))
+   PCL::INITIALIZE-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (OR (STRUCTURE) (MEMBER NIL)))
+   PCL::EXPAND-CACHE)) 
+(PROCLAIM '(FTYPE (FUNCTION (&REST T) (SYSTEM:TRUE)) PCL::TRUE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::NO-METHODS))
+   PCL::NO-METHODS-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::METHOD-CALL)) (STRUCTURE PCL::METHOD-CALL))
+   PCL::COPY-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((SYSTEM:STD-INSTANCE)) (T)) PCL::%STD-INSTANCE-SLOTS
+   PCL::%STD-INSTANCE-WRAPPER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (NULL) (NULL))) PCL::SAUT-PROTOTYPE)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T) (T) &REST T) (T)) PCL::REAL-GET-METHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (VALUES (T) (NULL) (STRUCTURE PCL::DISPATCH)))
+   PCL::MAKE-DISPATCH-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::METHOD-CALL))
+   PCL::MAKE-METHOD-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE)) (STRUCTURE)) PCL::COPY-STRUCTURE-OBJECT)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::INITIAL-DISPATCH-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T)) (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::CHECK-INITARGS-VALUES)) 
+(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::DFUN-INFO)) (STRUCTURE PCL::DFUN-INFO))
+   PCL::COPY-DFUN-INFO)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION (&REST T) (VALUES)) PCL::LIST-LARGE-CACHES)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+    (STRUCTURE PCL::ONE-INDEX-DFUN-INFO))
+   PCL::COPY-ONE-INDEX-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (OR (INTEGER 0 268435455) (MEMBER NIL)))
+   PCL::SYMBOL-LESSP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) &REST T) (VALUES (T) (T)))
+   PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+   PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS)) 
+(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) (T) (T) (T) (T) (T) (T)) (T))
+   PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (VALUES
+     &OPTIONAL
+     (OR
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+      (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:PROPER-CONS (T) (T))
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE) (SYSTEM:INTERPRETED-FUNCTION))
+     (NULL)))
+   PCL::EMIT-ONE-CLASS-WRITER PCL::EMIT-ONE-CLASS-READER
+   PCL::EMIT-TWO-CLASS-WRITER PCL::EMIT-TWO-CLASS-READER
+   PCL::EMIT-ONE-INDEX-WRITERS PCL::EMIT-ONE-INDEX-READERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T))))
+   PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::SAUT-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (STRUCTURE PCL::INITIAL)) PCL::INITIAL-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (VALUES &REST T))
+   SETF::|PCL::GENERIC-FUNCTION-DECLARATIONS|
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OWNER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM HAS-HOLES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM NAMED slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL IDENTITY-WITH-ONE-ARGUMENT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER DEF slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LINE-SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER DEF slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER RETURN-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM STATICP slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-DESCRIPTIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SLOT-POSITION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PV-SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NEXT-METHOD-CALL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INDEX slot READER|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INDEX slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OFFSET slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot READER|
+   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL FROM-DEFCLASS-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LIMIT-FN slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL MAX-LOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL FIELD slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NAME slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL FIELD slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot READER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER VALUE-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER CALLEES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER MACROS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER FUN-VALUES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP DOCUMENTATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD-COMBINATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP GENERIC-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP LENGTH slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP METHOD slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMMON-LISP VECTOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-AFTER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PLIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OPERATOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OVERFLOW slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-VALID-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-RI-VALID-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-INITARGS-FORM-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITARGS-FORM-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-NEW-KEYS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-DEFAULT-INITARGS-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-T-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-SHARED-INITIALIZE-NIL-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-CONSTANTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-COMBINED-INITIALIZE-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFORM slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CAN-PRECEDE-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PV-CELL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-DEFINITION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PROTOTYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-READER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INTERNAL-WRITER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITARGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SLOTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUPERCLASSES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-SUBCLASSES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DIRECT-METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL RECOMP-REASONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INCOMPATIBLE-SUPERCLASS-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CALL-METHOD-ARGS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARGUMENTS-LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL FAST-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-SUPERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot READER|
+   SLOT-ACCESSOR-NAME::|PCL LOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM FROZEN slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITFUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONC-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SLOT-NAME-LISTS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL NLINES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL NLINES slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER NO-EMIT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SIZE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SIZE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NAME slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NKEYS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL VALUEP slot READER|
+   SLOT-ACCESSOR-NAME::|PCL INITIAL-METHODS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL INITIALIZE-INFO slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NKEYS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL VALUEP slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-PRECOMPUTE-DFUN-AND-EMF-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL WRITER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL KEY slot READER|
+   SLOT-ACCESSOR-NAME::|PCL KEY slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-PRECEDENCE-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READERS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL LOAD-ENV slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CPD-CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PRETTY-ARGLIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM CONSTRUCTORS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CPD-COUNT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DFUN-STATE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ACCESSOR-FLAGS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL CLASS-EQ-SPECIALIZER slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRITERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PREDICATE-NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ALLOCATION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DECLARATIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SLOTS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SOURCE slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDED slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM INCLUDES slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL CACHE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL METHODS slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|SYSTEM PRINT-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL PORT slot READER|
+   SLOT-ACCESSOR-NAME::|PCL PORT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL NAME slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot READER|
+   SLOT-ACCESSOR-NAME::|PCL NAME slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-ACCESSOR-SYMBOL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-FORM slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL DEFSTRUCT-CONSTRUCTOR slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL READER-FUNCTION slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot READER|
+   SLOT-ACCESSOR-NAME::|PCL SPECIALIZERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM RAW slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot READER|
+   SLOT-ACCESSOR-NAME::|SYSTEM OBJECT slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot READER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot READER|
+   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot READER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-LAMBDA-LIST slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-PRECEDENCE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-METATYPES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-NUMBER-OPTIONAL slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEY/REST-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL ARG-INFO-KEYWORDS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-SIMPLE-ACCESSOR-TYPE slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-STATIC-C-A-M-EMF slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-C-A-M-EMF-STD-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL GF-INFO-FAST-MF-P slot WRITER|
+   SLOT-ACCESSOR-NAME::|COMPILER ARG-TYPES slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL BOUNDP-FUNCTION slot BOUNDP|
+   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL COMP-ENV slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL OPTIONS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL READERS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot READER|
+   SLOT-ACCESSOR-NAME::|PCL MASK slot READER|
+   SLOT-ACCESSOR-NAME::|PCL READERS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL METHOD-CLASS slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL MASK slot WRITER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL OWNER slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER0 slot READER|
+   SLOT-ACCESSOR-NAME::|PCL WRAPPER1 slot READER| NO-APPLICABLE-METHOD
+   PCL:UPDATE-DEPENDENT SLOT-MISSING SLOT-UNBOUND
+   PCL:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER INVALID-METHOD-ERROR
+   METHOD-COMBINATION-ERROR PCL::REMOVE-NAMED-METHOD
+   PCL::|PCL::TRACED-METHOD class predicate| PCL::USE-PACKAGE-PCL
+   PCL::|COMMON-LISP::NULL class predicate|
+   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
+   PCL::|COMMON-LISP::SYMBOL class predicate|
+   PCL::|COMMON-LISP::CHARACTER class predicate|
+   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
+   PCL::|COMMON-LISP::STRING class predicate|
+   PCL::|COMMON-LISP::VECTOR class predicate|
+   PCL::|COMMON-LISP::ARRAY class predicate|
+   PCL::|COMMON-LISP::STREAM class predicate|
+   PCL::|COMMON-LISP::FILE-STREAM class predicate|
+   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
+   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
+   PCL::|COMMON-LISP::STRING-STREAM class predicate|
+   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
+   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
+   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
+   PCL::|COMMON-LISP::HASH-TABLE class predicate|
+   PCL::|COMMON-LISP::PACKAGE class predicate|
+   PCL::|COMMON-LISP::READTABLE class predicate|
+   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
+   PCL::|COMMON-LISP::PATHNAME class predicate|
+   PCL::|COMMON-LISP::CONS class predicate|
+   PCL::|COMMON-LISP::LIST class predicate|
+   PCL::|COMMON-LISP::SEQUENCE class predicate|
+   PCL::|COMMON-LISP::RATIO class predicate|
+   PCL::|COMMON-LISP::INTEGER class predicate|
+   PCL::|COMMON-LISP::RATIONAL class predicate|
+   PCL::|COMMON-LISP::REAL class predicate|
+   PCL::|COMMON-LISP::FLOAT class predicate|
+   PCL::|COMMON-LISP::COMPLEX class predicate|
+   PCL::|COMMON-LISP::NUMBER class predicate|
+   PCL::|COMMON-LISP::T class predicate|
+   PCL::|COMMON-LISP::FUNCTION class predicate|
+   PCL::|COMMON-LISP::STRUCTURE-OBJECT class predicate|
+   PCL::|COMMON-LISP::STANDARD-OBJECT class predicate|
+   PCL::|COMMON-LISP::BUILT-IN-CLASS class predicate|
+   PCL::|PCL::SPECIALIZER-WITH-OBJECT class predicate|
+   PCL::|PCL::MODULE class predicate|
+   PCL::|PCL::ONE-INDEX-DFUN-INFO class predicate|
+   PCL::|PCL::DOCUMENTATION-MIXIN class predicate|
+   PCL::|PCL::ONE-CLASS class predicate|
+   PCL::|PCL::SLOT-OBJECT class predicate|
+   PCL::|PCL::INITIALIZE-INFO class predicate|
+   PCL::|PCL::CACHE class predicate|
+   PCL::|PCL::SLOT-DEFINITION class predicate|
+   PCL::|PCL::DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|SYSTEM::S-DATA class predicate|
+   PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE
+   PCL::|PCL::PLIST-MIXIN class predicate|
+   PCL::|PCL::CLASS-PRECEDENCE-DESCRIPTION class predicate|
+   PCL::|PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate|
+   PCL::|PCL::TWO-CLASS class predicate|
+   PCL::|PCL::CHECKING class predicate|
+   PCL::|PCL::DFUN-INFO class predicate|
+   PCL::|COMPILER::FN class predicate|
+   PCL::|PCL::EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::FUNCALLABLE-STANDARD-OBJECT class predicate|
+   PCL::|PCL::METHOD-CALL class predicate|
+   PCL::|PCL::METAOBJECT class predicate|
+   PCL::|PCL::DEPENDENT-UPDATE-MIXIN class predicate|
+   PCL::|PCL::DEFINITION-SOURCE-MIXIN class predicate|
+   PCL::ARG-INFO-READER PCL::UPDATE-CONSTRUCTORS
+   PCL::|PCL::STD-CLASS class predicate|
+   PCL::|PCL::PCL-CLASS class predicate|
+   PCL::|PCL::ACCESSOR-DFUN-INFO class predicate|
+   PCL::COMPATIBLE-META-CLASS-CHANGE-P
+   PCL::|PCL::FAST-METHOD-CALL class predicate|
+   PCL::|PCL::STANDARD-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-DIRECT-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
+   PCL::|PCL::STANDARD-METHOD-COMBINATION class predicate|
+   PCL::|PCL::FAST-INSTANCE-BOUNDP class predicate|
+   PCL::|PCL::ARG-INFO class predicate|
+   PCL::|PCL::PV-TABLE class predicate|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-LOAD-FORM (CLASS))| PCL::EXPAND-DEFCLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    (&REST T)
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::MAKE-PROGN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (STRUCTURE PCL::ONE-INDEX))
+   PCL::ONE-INDEX-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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) (T) (T) (T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     &OPTIONAL (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))) (T)))
+   ITERATE::PARSE-DECLARATIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (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 (&REST T) (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (OR
+     (OR
+      (OR
+       (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+       (SIMPLE-ARRAY BIT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+       (SIMPLE-ARRAY SHORT-FLOAT (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+       (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+       (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+       (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+       (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+       (SIMPLE-ARRAY FIXNUM (*)))
+      (OR
+       (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+       (SYSTEM::NON-SIMPLE-ARRAY T *) (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::SORT-CALLS PCL::METHOD-LL->GENERIC-FUNCTION-LL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) (SYSTEM:TRUE))
+   PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+   ITERATE::VARIABLES-FROM-LET PCL:EXTRACT-SPECIALIZER-NAMES
+   PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::EARLY-COLLECT-CPL
+   PCL::FORMAT-CYCLE-REASONS PCL::EXTRACT-PARAMETERS
+   PCL::EXTRACT-REQUIRED-PARAMETERS PCL::UNPARSE-SPECIALIZERS
+   PCL::COMPUTE-CLASS-SLOTS PCL::DEFAULT-CONSTANT-CONVERTER
+   PCL::SORT-SLOTS)) 
+(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::METHOD-CALL))
+    (OR
+     (OR
+      (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+      (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::METHOD-CALL-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) (T)) (NOT (MEMBER NIL))) PCL::PV-TABLE-LOOKUP)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EARLY-ACCESSOR PCL::MAKE-UNORDERED-METHODS-EMF
+   PCL::ACCESSOR-MISS-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHE)) PCL::|__si::MAKE-CACHE|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::DISPATCH)) (STRUCTURE PCL::DISPATCH))
+   PCL::COPY-DISPATCH)) 
+(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) (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)) (SIMPLE-ARRAY T (*))) PCL::GET-CACHE-VECTOR
+   PCL::FLUSH-CACHE-VECTOR-INTERNAL PCL::MAKE-PERMUTATION-VECTOR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T)) (OR (MEMBER "a function") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::NO-METHODS))
+   PCL::|__si::MAKE-NO-METHODS|)) 
+(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
+    ((INTEGER 0 9223372036854775807) (T) &REST T)
+    (VALUES &OPTIONAL (T) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::FIND-FREE-CACHE-LINE)) 
+(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)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T)
+     (OR
+      (OR
+       (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+       (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+      (SYSTEM:INTERPRETED-FUNCTION)))
+    (VALUES &REST T))
+   PCL::ORDER-SPECIALIZERS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) (T) (T) (T)) NIL)
+   PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|)) 
+(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)) (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
+    ((OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (T))
+    (SYSTEM:PROPER-CONS (T) (T)))
+   PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (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)) (VALUES (T) (T)))
+   PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::EARLY-METHOD-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:PROPER-CONS (T) (T)))
+   ITERATE::SIMPLE-EXPAND-ITERATE-FORM PCL::DEAL-WITH-ARGUMENTS-OPTION
+   PCL::MEC-ALL-CLASSES-INTERNAL PCL::MAKE-DFUN-ARG-LIST
+   PCL::CANONICALIZE-DEFCLASS-OPTION
+   PCL::CANONICALIZE-SLOT-SPECIFICATION
+   PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
+   PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
+   PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION PCL::EMIT-1-NIL-DLAP
+   PCL::MAKE-CAXR)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL))
+   PCL::|__si::MAKE-INITIAL|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+    (STRUCTURE PCL::ACCESSOR-DFUN-INFO))
+   PCL::COPY-ACCESSOR-DFUN-INFO)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES
+     (OR
+      (INTEGER -9223372036854775808 9223372036854775807) (MEMBER NIL))
+     (T)
+     (OR
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))))
+   PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (VALUES (NULL) (OR (SYSTEM:TRUE) (NULL))))
+   PCL::SAUT-NOT)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (OR (MEMBER NIL) (SYSTEM:PROPER-CONS (T) (T)) (MEMBER T)))
+   PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::CLASS-MIGHT-PRECEDE-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::ADJUST-CACHE PCL::FILL-CACHE-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::PV-TABLE))
+    (OR (STRUCTURE PCL::CACHE) (MEMBER NIL)))
+   PCL::PV-TABLE-CACHE)) 
+(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) (T)) (VALUES &REST T))
+   PCL:COMPUTE-APPLICABLE-METHODS-USING-CLASSES PCL:MAP-DEPENDENTS
+   PCL:REMOVE-DIRECT-SUBCLASS PRINT-OBJECT
+   PCL:COMPUTE-EFFECTIVE-SLOT-DEFINITION PCL:REMOVE-DIRECT-METHOD
+   PCL:VALIDATE-SUPERCLASS PCL:ADD-DIRECT-SUBCLASS ADD-METHOD
+   PCL:ADD-DIRECT-METHOD PCL:ADD-DEPENDENT PCL:REMOVE-DEPENDENT
+   SLOT-VALUE PCL:EFFECTIVE-SLOT-DEFINITION-CLASS
+   PCL:DIRECT-SLOT-DEFINITION-CLASS REMOVE-METHOD
+   COMPUTE-APPLICABLE-METHODS DESCRIBE-OBJECT
+   PCL::LEGAL-DOCUMENTATION-P PCL::REMOVE-BOUNDP-METHOD
+   PCL::%NO-PRIMARY-METHOD PCL::LEGAL-SPECIALIZER-P
+   PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
+   PCL::MAKE-DIRECT-SLOTD PCL::LEGAL-QUALIFIER-P PCL::CLASS-SLOT-VALUE
+   PCL::DEFAULT-INITARGS PCL::UPDATE-SLOT-VALUE-GF-INFO
+   PCL::LEGAL-SLOT-NAME-P PCL::COMPUTE-TEST PCL::SLOTS-TO-INSPECT
+   PCL::SAME-SPECIALIZER-P PCL::SDFUN-FOR-CACHING
+   PCL::LEGAL-METHOD-FUNCTION-P PCL::MAKE-READER-METHOD-FUNCTION
+   PCL::SLOT-ACCESSOR-FUNCTION PCL::SLOT-ACCESSOR-STD-P
+   PCL::LEGAL-SPECIALIZERS-P PCL::MAKE-WRITER-METHOD-FUNCTION
+   PCL::LEGAL-QUALIFIERS-P PCL::INVOKE-EMF
+   PCL::MAKE-BOUNDP-METHOD-FUNCTION PCL::INFORM-TYPE-SYSTEM-ABOUT-CLASS
+   DOCUMENTATION PCL::SLOT-VALUE-NORMAL
+   PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::REMOVE-WRITER-METHOD
+   PCL::UPDATE-GF-DFUN PCL::INITIAL-DFUN PCL::REMOVE-READER-METHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     (T)
+     (OR
+      (OR
+       (OR
+        (SIMPLE-ARRAY NIL (*)) (SIMPLE-ARRAY CHARACTER (*))
+        (SIMPLE-ARRAY BIT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-CHAR (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-SHORT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-SHORT (*))
+        (SIMPLE-ARRAY SHORT-FLOAT (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-INT (*))
+        (SIMPLE-ARRAY SYSTEM:UNSIGNED-INT (*))
+        (SIMPLE-ARRAY SYSTEM:SIGNED-INT (*))
+        (SIMPLE-ARRAY LONG-FLOAT (*)) (SIMPLE-ARRAY T (*))
+        (SIMPLE-ARRAY SYSTEM:NON-NEGATIVE-FIXNUM (*))
+        (SIMPLE-ARRAY FIXNUM (*)))
+       (OR
+        (SYSTEM::NON-SIMPLE-ARRAY CHARACTER *)
+        (SYSTEM::NON-SIMPLE-ARRAY T *)
+        (SYSTEM::NON-SIMPLE-ARRAY BIT *)))
+      (OR (NULL) (SYSTEM:PROPER-CONS (T) (T))))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::EXTRACT-DECLARATIONS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (SYSTEM:STD-INSTANCE))
+   PCL::|__si::MAKE-STD-INSTANCE|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES
+     (OR
+      (OR
+       (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+      (NULL))
+     (INTEGER -9223372036854775807 9223372036854775807)))
+   PCL::COMPUTE-STD-CPL-PHASE-1)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (T) &REST T) (VALUES &REST T))
+   UPDATE-INSTANCE-FOR-REDEFINED-CLASS
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1
+   PCL::EARLY-ADD-NAMED-METHOD)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1
+   PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY
+   PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::STD-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+    (STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION))
+   PCL::COPY-CLASS-PRECEDENCE-DESCRIPTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (VALUES &OPTIONAL (T) (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (SYSTEM:PROPER-CONS (T) (T)))
+   WALKER::WALKER-ENVIRONMENT-BIND-1)) 
+(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
+    ((STRUCTURE PCL::CACHE) (INTEGER 0 9223372036854775807) &REST T)
+    (INTEGER 0 9223372036854775807))
+   PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
+(PROCLAIM
+ '(FTYPE (FUNCTION ((T) &REST T) (VALUES)) PCL::PCL-DESCRIBE DESCRIBE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T)) (MEMBER PCL::ALLOCATE-FUNCALLABLE-INSTANCE))
+   PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (NULL)) PCL::SHOW-EMF-CALL-TRACE PCL::RENEW-SYS-FILES
+   PCL::BOOTSTRAP-BUILT-IN-CLASSES PCL::SHOW-DFUN-CONSTRUCTORS
+   PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-BINDINGS-1 PCL::OPTIMIZE-GENERIC-FUNCTION-CALL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::ONE-CLASS))
+   PCL::|__si::MAKE-ONE-CLASS|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (PACKAGE) (MEMBER NIL))) PCL::CONSTANT-SYMBOL-P
+   PCL::INTERNED-SYMBOL-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::INITIAL-DISPATCH)) (T))
+   PCL::INITIAL-DISPATCH-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   WALKER::WALK-BINDINGS-2)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((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))
+    (OR
+     (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION)
+     (SYSTEM::IMPROPER-CONS (T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE)
+     (SYSTEM:INTERPRETED-FUNCTION)))
+   PCL::GET-NEW-FUNCTION-GENERATOR PCL::TRACE-METHOD-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (INTEGER 0 9223372036854775807)) PCL::CACHE-COUNT)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:FUNCALLABLE-STD-INSTANCE))
+   PCL:SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (STRUCTURE) (T)) NIL)
+   PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T)) (SYSTEM:TRUE)) PCL::METHOD-FUNCTION-RETURNING-T)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::TWO-CLASS)) (STRUCTURE PCL::TWO-CLASS))
+   PCL::COPY-TWO-CLASS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES
+     &OPTIONAL (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   PCL::REAL-MAKE-METHOD-LAMBDA)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T))
+    (VALUES (T) (NOT (MEMBER NIL)) (STRUCTURE PCL::CONSTANT-VALUE)))
+   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::INITIAL-DISPATCH))
+   PCL::|__si::MAKE-INITIAL-DISPATCH|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T)) (OR (INTEGER 0 12) (MEMBER NIL)))
+   PCL::WRAPPER-FIELD)) 
+(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 ((T)) (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::COMPILE-LAMBDA-UNCOMPILED PCL::MAKE-EQL-PREDICATE
+   PCL::CLASS-PREDICATE PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
+   PCL::EVAL-FORM PCL::COMPILE-LAMBDA-DEFERRED PCL::MAKE-TYPE-PREDICATE
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
+   PCL::MAKE-TRAMPOLINE PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION
+   PCL::MAKE-CLASS-EQ-PREDICATE PCL::MAKE-CONSTANT-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((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::NO-METHODS)) (STRUCTURE PCL::NO-METHODS))
+   PCL::COPY-NO-METHODS)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::ONE-INDEX)) (T)) PCL::ONE-INDEX-CACHE
+   PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-ACCESSOR-TYPE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T) (NULL) (T)) (T))
+   PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (VALUES
+     &OPTIONAL (SYSTEM:PROPER-CONS (T) (T))
+     (OR (NULL) (SYSTEM:PROPER-CONS (T) (T)))))
+   MAKE-LOAD-FORM-SAVING-SLOTS PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T))))
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::MAKE-DISPATCH-LAMBDA)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T))
+    (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
+    ((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))
+    (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION))
+   PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
+   PCL::MAKE-INSTANCE-FUNCTION-COMPLEX)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CONSTANT-VALUE)) (T))
+   PCL::CONSTANT-VALUE-CACHE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T)) (OR (MEMBER "a string or NULL") (MEMBER T)))
+   PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION (&REST T) (STRUCTURE PCL::CACHING))
+   PCL::|__si::MAKE-CACHING|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CACHE)) (INTEGER 0 9223372036854775807))
+   PCL::CACHE-MAX-LOCATION PCL::CACHE-MASK PCL::CACHE-NLINES
+   PCL::CACHE-SIZE)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T))
+    (VALUES
+     (T)
+     (OR
+      (SYSTEM::NON-SIMPLE-ARRAY T *) (SIMPLE-ARRAY T *) (MEMBER NIL))))
+   PCL::MAKE-SHARED-INITIALIZE-FORM-LIST)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) (T) (T) (T))
+    (VALUES (T) (NULL) (STRUCTURE PCL::TWO-CLASS)))
+   PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) (T) &REST T)
+    (VALUES
+     &OPTIONAL (T) (T)
+     (OR
+      (MEMBER NIL)
+      (OR
+       (STRUCTURE PCL::ONE-CLASS) (STRUCTURE PCL::ONE-INDEX)
+       (STRUCTURE PCL::CACHING) (STRUCTURE PCL::CONSTANT-VALUE)
+       (STRUCTURE PCL::DISPATCH) (STRUCTURE PCL::N-N)))))
+   PCL::MAKE-FINAL-ACCESSOR-DFUN)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) &REST T) (OR (SYSTEM:TRUE) (NULL)))
+   PCL::USE-DISPATCH-DFUN-P PCL::USE-CONSTANT-VALUE-DFUN-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)) 
+(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)) (NULL))
+   PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+   PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
+   PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION NIL (INTEGER 1 134217727)) PCL::GET-WRAPPER-CACHE-NUMBER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T))
+    (OR (SYSTEM:NON-STANDARD-OBJECT-COMPILED-FUNCTION) (MEMBER NIL)))
+   PCL::GET-MAKE-INSTANCE-FUNCTION)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION
+    ((T) &REST T)
+    (OR
+     (OR (SYSTEM:PROPER-CONS (T) (T)) (SYSTEM::IMPROPER-CONS (T) (T)))
+     (NULL)))
+   ITERATE::FUNCTION-LAMBDA-P)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((STRUCTURE PCL::CLASS-PRECEDENCE-DESCRIPTION)) (T))
+   PCL::CPD-CLASS PCL::CPD-SUPERS PCL::CPD-AFTER)) 
+(PROCLAIM
+ '(FTYPE
+   (FUNCTION ((T) (T) (T)) (MEMBER PCL::FSC-INSTANCE-SLOTS))
+   PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|)) 
\ No newline at end of file
--- gcl27-2.7.0.orig/unixport/init_raw.lsp.in
+++ gcl27-2.7.0/unixport/init_raw.lsp.in
@@ -58,8 +58,8 @@
        (pcl (append x (list "pcl")))
        (clcs (append x (list "clcs")))
        (gtk (append x (list "gcl-tk"))))
-  (dolist (d (list lsp cmpnew #+(and xgcl (not pre-gcl)) xgcl-2 #+(or pcl ansi-cl) pcl #+ansi-cl clcs))
-    (load (make-pathname :name "sys-proclaim" :type "lisp" :directory d)))
+  ;; (dolist (d (list lsp cmpnew #+(and xgcl (not pre-gcl)) xgcl-2 #+(or pcl ansi-cl) pcl #+ansi-cl clcs))
+  ;;   (load (make-pathname :name "sys-proclaim" :type "lisp" :directory d)))
   (load (make-pathname :name "tk-package" :type "lsp" :directory gtk))
   (load (make-pathname :name "gcl_lfun_list" :type "lsp" :directory cmpnew))
   (load (make-pathname :name "gcl_cmpopt" :type "lsp" :directory cmpnew))
--- gcl27-2.7.0.orig/unixport/sys_init.c
+++ gcl27-2.7.0/unixport/sys_init.c
@@ -229,52 +229,3 @@ gcl_init_system(object no_init)
 #endif
   
 }
-
-#if defined(pcl_gcl) ||  defined(ansi_gcl)
-static int ngazonk;
-#endif
-
-int
-gcl_init_cmp_anon(void) {
-
-  int i=0;
-
-#if defined(pcl_gcl) ||  defined(ansi_gcl)
-  switch(ngazonk++) {
-  case 0:
-    check_init(pcl,gcl_pcl_gazonk0,Cnil);
-    break;
-  case 1:
-    check_init(pcl,gcl_pcl_gazonk1,Cnil);
-    break;
-  case 2:
-    check_init(pcl,gcl_pcl_gazonk2,Cnil);
-    break;
-  case 3:
-    check_init(pcl,gcl_pcl_gazonk3,Cnil);
-    break;
-  case 4:
-    check_init(pcl,gcl_pcl_gazonk4,Cnil);
-    break;
-  case 5:
-    check_init(pcl,gcl_pcl_gazonk5,Cnil);
-    break;
-  case 6:
-    check_init(pcl,gcl_pcl_gazonk6,Cnil);
-    break;
-  case 7:
-    check_init(pcl,gcl_pcl_gazonk7,Cnil);
-  /*   break; */
-  /* case 8: */
-  /*   check_init(gcl_pcl_gazonk8,Cnil); */
-    i=1;
-    break;
-  default:
-    i=-1;
-    break;
-  }
-#endif
-  
-  return i;
-
-}
