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-35) unstable; urgency=medium
 .
   * Version_2_7_0pre38
   * Bug fix: "ftbfs with GCC-15", thanks to Matthias Klose (Closes:
     #1096686).
Author: Camm Maguire <camm@debian.org>
Bug-Debian: https://bugs.debian.org/1096686

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

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

--- gcl27-2.7.0.orig/cmpnew/gcl_cmpflet.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpflet.lsp
@@ -491,6 +491,7 @@
 	 (sig (list (mapcar  (lambda (x) (link-rt x t)) (car sig)) (link-rt (cadr sig) t)))
 	 (mv (not (single-type-p (cadr sig))))
 	 (nm (c-function-name "L" (fun-cfun fun) (fun-name fun)))
+	 (nm (concatenate 'string "(" (rep-type (coerce-to-one-value (cadr sig))) ")" nm))
 	 (clp (when clp (ccb-vs-str (fun-ref-ccb fun))))
 	 (nm (if clp (ms clp "->fun.fun_self") nm))
 	 (inl (g1 clp nm sig ap clp (if clp -1 (fun-level fun)))))
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpfun.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpfun.lsp
@@ -288,7 +288,8 @@
 	     (c1progn (append args (list r)) (nconc nargs (list (if r (c1t) (c1nil)))))))
 	  ((let ((x (get-vbind (car nargs)))(y (get-vbind (cadr nargs))))
 	     (when (or (when x (eq x y)) (and (symbolp (car args)) (eq (car args) (cadr args))))
-	       (if (member fn '(= >= <=)) (c1t) (c1nil)))));FIXME nan
+	       (unless (type-and (type-or1 t1 t2) #t(or (short-float unordered) (long-float unordered)))
+		 (if (member fn '(= >= <=)) (c1t) (c1nil))))))
 	  ((list 'call-global info fn nargs)))))
 
 (dolist (l `(>= > < <= = /=))
@@ -410,7 +411,7 @@
 ;; or :out-file
 
 ;(si::putprop 'read-byte 'co1read-byte 'co1)
-(si::putprop 'read-char 'co1read-char 'co1)
+#-cygwin(si::putprop 'read-char 'co1read-char 'co1)
 (si::putprop 'write-byte 'co1write-byte 'co1)
 (si::putprop 'write-char 'co1write-char 'co1)
 
--- gcl27-2.7.0.orig/cmpnew/gcl_cmpspecial.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmpspecial.lsp
@@ -262,7 +262,8 @@
       (wt "symbol_function(" (vv-str vv) ")")
     (wt "(" (vv-str vv) "->s.s_gfdef)")))
 
-(defun wt-make-cclosure (cfun fname call argd sizes args)
+(defun wt-make-cclosure (cfun fname call argd sizes &rest r &aux (args (car r)))
+  (declare (dynamic-extent r))
   (declare (ignore args))
   (wt "fSinit_function(")
   (wt-vv call)
--- gcl27-2.7.0.orig/cmpnew/gcl_cmptop.lsp
+++ gcl27-2.7.0/cmpnew/gcl_cmptop.lsp
@@ -872,7 +872,8 @@
     (setf (sixth form) (new-bind form))
     form))
 
-(defun c2lit (key inl args bind safety oargs stores &aux (tp (get key 'cmp-lisp-type :opaque)))
+(defun c2lit (key inl args bind safety &rest r &aux (oargs (pop r)) (stores (car r)) (tp (get key 'cmp-lisp-type :opaque)))
+  (declare (dynamic-extent r))
   (let* ((*inline-blocks* 0)
 	 (*restore-avma*  *restore-avma*)
 	 (*compiler-check-args* *compiler-check-args*)
@@ -1216,8 +1217,8 @@
     (if mv `(,(car tp) ,@(when (cdr tp) `(,tppn)) ,@(cddr tp)) tppn)))
 
 
-(defun t2defun (fname cfun lambda-expr doc sp macro-p)
-  (declare (ignore cfun lambda-expr doc sp macro-p))
+(defun t2defun (fname cfun lambda-expr doc sp &rest r &aux (macro-p (car r)))
+  (declare (dynamic-extent r)(ignore cfun lambda-expr doc sp macro-p))
 
   (cond ((get fname 'no-global-entry)(return-from t2defun nil)))
   
@@ -1246,10 +1247,11 @@
     (add-init `(fset ',fname ,(if macro-p `(cons 'macro ,finit) finit)))))
 
 
-(defun t3defun (fname cfun lambda-expr doc sp macro-p &aux inline-info 
+(defun t3defun (fname cfun lambda-expr doc sp &rest r &aux (macro-p (car r)) inline-info 
 ;		      (macro-p (equal `(mflag ,fname) (cadr (member *current-form* *top-level-forms*))))
 		      (*current-form* (list 'defun fname))
 		      (*volatile* (volatile (second lambda-expr))))
+  (declare (dynamic-extent r))
 
   (let ((*compiler-check-args* *compiler-check-args*)
         (*safe-compile* *safe-compile*)
@@ -1290,7 +1292,6 @@
 
     (add-debug-info fname lambda-expr)))
 
-
 (defun t3defun-aux (f *exit* &rest lis)
   (let-pass3 ()   (apply f lis)))   
 
--- gcl27-2.7.0.orig/configure
+++ gcl27-2.7.0/configure
@@ -3095,6 +3095,7 @@ case $canonical in
     *86*linux*) use=386-linux;;
     *riscv64*linux*) use=riscv64-linux;;
     *86*kfreebsd*) use=386-kfreebsd;;
+    *86_64*gnu*)	use=amd64-gnu;;
     *86*gnu*)	use=386-gnu;;
     m68k*linux*) use=m68k-linux;;
     alpha*linux*) use=alpha-linux;;
@@ -5519,6 +5520,7 @@ printf "%s\n" "removing $1 from LDFLAGS"
 add_args_to_cflags  -fsigned-char -pipe -fcommon \
                     -fno-builtin-malloc -fno-builtin-free \
                     -fno-PIE -fno-pie -fno-PIC -fno-pic \
+	            -std=gnu17 \
 	            -Wall \
 	            -Wno-builtin-requires-header -Wno-empty-body -Wno-self-assign \
 	            -Wno-unused-but-set-variable
@@ -5835,83 +5837,83 @@ if test "$enable_pic" = "yes" ; then
     assert_arg_to_cflags -fPIC
 fi
 
-FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^\-g$"|tr '\012' ' '`
-#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-g$"`
-FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-fomit-frame-pointer$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-fomit-frame-pointer$"|tr '\012' ' '`
-FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O3$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O3$"|tr '\012' ' '`
-FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O2$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O2$"|tr '\012' ' '`
-FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O1$"|tr '\012' ' '`
-TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O$"|tr '\012' ' '`
+FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^-g$"|tr '\012' ' '`
+#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-g$"`
+FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^-fomit-frame-pointer$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-fomit-frame-pointer$"|tr '\012' ' '`
+FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^-O3$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O3$"|tr '\012' ' '`
+FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^-O2$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O2$"|tr '\012' ' '`
+FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^-O1$"|tr '\012' ' '`
+TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^-O$"|tr '\012' ' '`
 FOOPT1="$FOOPT1$TMPF"
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O1$"|grep -v "^\-O$"|tr '\012' ' '`
-FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O0$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O1$"|grep -v "^-O$"|tr '\012' ' '`
+FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O0$"|tr '\012' ' '`
 
 
 if test "$FOOPT0" != "" ; then
-   TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[123 ],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
-   TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[123 ],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
-   TOSFLAGS=`echo $TOSFLAGS | sed 's,\-O[123 ],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
+   TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[123 ],-O0 ,g' | sed 's,-O$,-O0 ,g'`
+   TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[123 ],-O0 ,g' | sed 's,-O$,-O0 ,g'`
+   TOSFLAGS=`echo $TOSFLAGS | sed 's,-O[123 ],-O0 ,g' | sed 's,-O$,-O0 ,g'`
 else
 if test "$FOOPT1" != "" ; then
-   TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[2-3],-O1,g'`
-   TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[2-3],-O1,g'`
-   TOSFLAGS=`echo $TOSFLAGS | sed 's,\-O[2-3],-O1,g'`
+   TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[2-3],-O1,g'`
+   TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[2-3],-O1,g'`
+   TOSFLAGS=`echo $TOSFLAGS | sed 's,-O[2-3],-O1,g'`
 else
 if test "$FOOPT2" != "" ; then
-   TO3FLAGS=`echo "$TO3FLAGS" | sed 's,\-O3,-O2,g'`
-   TO2FLAGS=`echo "$TO2FLAGS" | sed 's,\-O3,-O2,g'`
-   TOSFLAGS=`echo "$TOSFLAGS" | sed 's,\-O3,-O2,g'`
+   TO3FLAGS=`echo "$TO3FLAGS" | sed 's,-O3,-O2,g'`
+   TO2FLAGS=`echo "$TO2FLAGS" | sed 's,-O3,-O2,g'`
+   TOSFLAGS=`echo "$TOSFLAGS" | sed 's,-O3,-O2,g'`
 fi
 fi
 fi
 
 if test "$FDEBUG" != "" ; then
-   TO3FLAGS=`echo $TO3FLAGS | sed 's,\-fomit-frame-pointer,,g'`
-   TO2FLAGS=`echo $TO2FLAGS | sed 's,\-fomit-frame-pointer,,g'`
-   TOSFLAGS=`echo $TOSFLAGS | sed 's,\-fomit-frame-pointer,,g'`
+   TO3FLAGS=`echo $TO3FLAGS | sed 's,-fomit-frame-pointer,,g'`
+   TO2FLAGS=`echo $TO2FLAGS | sed 's,-fomit-frame-pointer,,g'`
+   TOSFLAGS=`echo $TOSFLAGS | sed 's,-fomit-frame-pointer,,g'`
 fi
 
 if test "$FOMITF" != "" ; then
    TO3FLAGS="$TO3FLAGS $FOMITF"
 fi
 
-FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^\-g$"|tr '\012' ' '`
-#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-g$"`
-FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-fomit-frame-pointer$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-fomit-frame-pointer$"|tr '\012' ' '`
-FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O3$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O3$"|tr '\012' ' '`
-FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O2$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O2$"|tr '\012' ' '`
-FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O1$"|tr '\012' ' '`
-TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O$"|tr '\012' ' '`
+FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^-g$"|tr '\012' ' '`
+#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-g$"`
+FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^-fomit-frame-pointer$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-fomit-frame-pointer$"|tr '\012' ' '`
+FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^-O3$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O3$"|tr '\012' ' '`
+FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^-O2$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O2$"|tr '\012' ' '`
+FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^-O1$"|tr '\012' ' '`
+TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^-O$"|tr '\012' ' '`
 FOOPT1="$FOOPT1$TMPF"
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O1$"|grep -v "^\-O$"|tr '\012' ' '`
-FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O0$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O1$"|grep -v "^-O$"|tr '\012' ' '`
+FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O0$"|tr '\012' ' '`
 
 if test "$FOOPT0" != "" ; then
-    TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[123 ],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
-    TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[123 ],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
+    TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[123 ],-O0 ,g' | sed 's,-O$,-O0 ,g'`
+    TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[123 ],-O0 ,g' | sed 's,-O$,-O0 ,g'`
 else
     if test "$FOOPT1" != "" ; then
-	TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[2-3],-O1,g'`
-	TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[2-3],-O1,g'`
+	TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[2-3],-O1,g'`
+	TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[2-3],-O1,g'`
     else
 	if test "$FOOPT2" != "" ; then
-	    TO3FLAGS=`echo "$TO3FLAGS" | sed 's,\-O3,-O2,g'`
-	    TO2FLAGS=`echo "$TO2FLAGS" | sed 's,\-O3,-O2,g'`
+	    TO3FLAGS=`echo "$TO3FLAGS" | sed 's,-O3,-O2,g'`
+	    TO2FLAGS=`echo "$TO2FLAGS" | sed 's,-O3,-O2,g'`
 	fi
     fi
 fi
 
 if test "$FDEBUG" != "" ; then
-    TO3FLAGS=`echo $TO3FLAGS | sed 's,\-fomit-frame-pointer,,g'`
-    TO2FLAGS=`echo $TO2FLAGS | sed 's,\-fomit-frame-pointer,,g'`
+    TO3FLAGS=`echo $TO3FLAGS | sed 's,-fomit-frame-pointer,,g'`
+    TO2FLAGS=`echo $TO2FLAGS | sed 's,-fomit-frame-pointer,,g'`
 fi
 
 if test "$FOMITF" != "" ; then
--- gcl27-2.7.0.orig/configure.in
+++ gcl27-2.7.0/configure.in
@@ -35,6 +35,7 @@ case $canonical in
     *86*linux*) use=386-linux;;
     *riscv64*linux*) use=riscv64-linux;;
     *86*kfreebsd*) use=386-kfreebsd;;
+    *86_64*gnu*)	use=amd64-gnu;;
     *86*gnu*)	use=386-gnu;;
     m68k*linux*) use=m68k-linux;;
     alpha*linux*) use=alpha-linux;;
@@ -269,6 +270,7 @@ remove_arg_from_ldflags() {
 add_args_to_cflags  -fsigned-char -pipe -fcommon \
                     -fno-builtin-malloc -fno-builtin-free \
                     -fno-PIE -fno-pie -fno-PIC -fno-pic \
+	            -std=gnu17 \
 	            -Wall \
 	            -Wno-builtin-requires-header -Wno-empty-body -Wno-self-assign \
 	            -Wno-unused-but-set-variable
@@ -475,83 +477,83 @@ if test "$enable_pic" = "yes" ; then
     assert_arg_to_cflags -fPIC
 fi
 
-FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^\-g$"|tr '\012' ' '`
-#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-g$"`
-FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-fomit-frame-pointer$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-fomit-frame-pointer$"|tr '\012' ' '`
-FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O3$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O3$"|tr '\012' ' '`
-FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O2$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O2$"|tr '\012' ' '`
-FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O1$"|tr '\012' ' '`
-TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O$"|tr '\012' ' '`
+FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^-g$"|tr '\012' ' '`
+#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-g$"`
+FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^-fomit-frame-pointer$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-fomit-frame-pointer$"|tr '\012' ' '`
+FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^-O3$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O3$"|tr '\012' ' '`
+FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^-O2$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O2$"|tr '\012' ' '`
+FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^-O1$"|tr '\012' ' '`
+TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^-O$"|tr '\012' ' '`
 FOOPT1="$FOOPT1$TMPF"
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O1$"|grep -v "^\-O$"|tr '\012' ' '`
-FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O0$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O1$"|grep -v "^-O$"|tr '\012' ' '`
+FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O0$"|tr '\012' ' '`
 
 
 if test "$FOOPT0" != "" ; then
-   TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[[123 ]],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
-   TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[[123 ]],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
-   TOSFLAGS=`echo $TOSFLAGS | sed 's,\-O[[123 ]],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
+   TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[[123 ]],-O0 ,g' | sed 's,-O$,-O0 ,g'`
+   TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[[123 ]],-O0 ,g' | sed 's,-O$,-O0 ,g'`
+   TOSFLAGS=`echo $TOSFLAGS | sed 's,-O[[123 ]],-O0 ,g' | sed 's,-O$,-O0 ,g'`
 else 
 if test "$FOOPT1" != "" ; then
-   TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[[2-3]],-O1,g'`
-   TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[[2-3]],-O1,g'`
-   TOSFLAGS=`echo $TOSFLAGS | sed 's,\-O[[2-3]],-O1,g'`
+   TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[[2-3]],-O1,g'`
+   TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[[2-3]],-O1,g'`
+   TOSFLAGS=`echo $TOSFLAGS | sed 's,-O[[2-3]],-O1,g'`
 else 
 if test "$FOOPT2" != "" ; then
-   TO3FLAGS=`echo "$TO3FLAGS" | sed 's,\-O3,-O2,g'`
-   TO2FLAGS=`echo "$TO2FLAGS" | sed 's,\-O3,-O2,g'`
-   TOSFLAGS=`echo "$TOSFLAGS" | sed 's,\-O3,-O2,g'`
+   TO3FLAGS=`echo "$TO3FLAGS" | sed 's,-O3,-O2,g'`
+   TO2FLAGS=`echo "$TO2FLAGS" | sed 's,-O3,-O2,g'`
+   TOSFLAGS=`echo "$TOSFLAGS" | sed 's,-O3,-O2,g'`
 fi
 fi
 fi
 
 if test "$FDEBUG" != "" ; then
-   TO3FLAGS=`echo $TO3FLAGS | sed 's,\-fomit-frame-pointer,,g'`
-   TO2FLAGS=`echo $TO2FLAGS | sed 's,\-fomit-frame-pointer,,g'`
-   TOSFLAGS=`echo $TOSFLAGS | sed 's,\-fomit-frame-pointer,,g'`
+   TO3FLAGS=`echo $TO3FLAGS | sed 's,-fomit-frame-pointer,,g'`
+   TO2FLAGS=`echo $TO2FLAGS | sed 's,-fomit-frame-pointer,,g'`
+   TOSFLAGS=`echo $TOSFLAGS | sed 's,-fomit-frame-pointer,,g'`
 fi
 
 if test "$FOMITF" != "" ; then
    TO3FLAGS="$TO3FLAGS $FOMITF"
 fi
 
-FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^\-g$"|tr '\012' ' '`
-#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-g$"`
-FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-fomit-frame-pointer$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-fomit-frame-pointer$"|tr '\012' ' '`
-FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O3$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O3$"|tr '\012' ' '`
-FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O2$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O2$"|tr '\012' ' '`
-FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O1$"|tr '\012' ' '`
-TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O$"|tr '\012' ' '`
+FDEBUG=`echo $CFLAGS | tr ' ' '\012' |grep "^-g$"|tr '\012' ' '`
+#CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-g$"`
+FOMITF=`echo $CFLAGS | tr ' ' '\012' |grep "^-fomit-frame-pointer$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-fomit-frame-pointer$"|tr '\012' ' '`
+FOOPT3=`echo $CFLAGS | tr ' ' '\012' |grep "^-O3$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O3$"|tr '\012' ' '`
+FOOPT2=`echo $CFLAGS | tr ' ' '\012' |grep "^-O2$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O2$"|tr '\012' ' '`
+FOOPT1=`echo $CFLAGS | tr ' ' '\012' |grep "^-O1$"|tr '\012' ' '`
+TMPF=`echo $CFLAGS | tr ' ' '\012' |grep "^-O$"|tr '\012' ' '`
 FOOPT1="$FOOPT1$TMPF"
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O1$"|grep -v "^\-O$"|tr '\012' ' '`
-FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^\-O0$"|tr '\012' ' '`
-CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^\-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O1$"|grep -v "^-O$"|tr '\012' ' '`
+FOOPT0=`echo $CFLAGS | tr ' ' '\012' |grep "^-O0$"|tr '\012' ' '`
+CFLAGS=`echo $CFLAGS | tr ' ' '\012' |grep -v "^-O0$"|tr '\012' ' '`
 
 if test "$FOOPT0" != "" ; then
-    TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[[123 ]],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
-    TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[[123 ]],-O0 ,g' | sed 's,\-O$,-O0 ,g'`
+    TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[[123 ]],-O0 ,g' | sed 's,-O$,-O0 ,g'`
+    TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[[123 ]],-O0 ,g' | sed 's,-O$,-O0 ,g'`
 else
     if test "$FOOPT1" != "" ; then
-	TO3FLAGS=`echo $TO3FLAGS | sed 's,\-O[[2-3]],-O1,g'`
-	TO2FLAGS=`echo $TO2FLAGS | sed 's,\-O[[2-3]],-O1,g'`
+	TO3FLAGS=`echo $TO3FLAGS | sed 's,-O[[2-3]],-O1,g'`
+	TO2FLAGS=`echo $TO2FLAGS | sed 's,-O[[2-3]],-O1,g'`
     else
 	if test "$FOOPT2" != "" ; then
-	    TO3FLAGS=`echo "$TO3FLAGS" | sed 's,\-O3,-O2,g'`
-	    TO2FLAGS=`echo "$TO2FLAGS" | sed 's,\-O3,-O2,g'`
+	    TO3FLAGS=`echo "$TO3FLAGS" | sed 's,-O3,-O2,g'`
+	    TO2FLAGS=`echo "$TO2FLAGS" | sed 's,-O3,-O2,g'`
 	fi
     fi
 fi
 
 if test "$FDEBUG" != "" ; then
-    TO3FLAGS=`echo $TO3FLAGS | sed 's,\-fomit-frame-pointer,,g'`
-    TO2FLAGS=`echo $TO2FLAGS | sed 's,\-fomit-frame-pointer,,g'`
+    TO3FLAGS=`echo $TO3FLAGS | sed 's,-fomit-frame-pointer,,g'`
+    TO2FLAGS=`echo $TO2FLAGS | sed 's,-fomit-frame-pointer,,g'`
 fi
 
 if test "$FOMITF" != "" ; then
--- gcl27-2.7.0.orig/git.tag
+++ gcl27-2.7.0/git.tag
@@ -1,2 +1,2 @@
-"Version_2_7_0pre37"
+"Version_2_7_0pre38"
 
--- gcl27-2.7.0.orig/h/386-gnu.h
+++ gcl27-2.7.0/h/386-gnu.h
@@ -54,11 +54,16 @@
 #endif
 #define PATH_MAX 4096 /*fixme dynamic*/
 #define MAXPATHLEN 4096 /*fixme dynamic*/
-#define MAX_BRK 0x70000000 /*GNU Hurd fragmentation bug*/
+/* #define MAX_BRK 0x70000000 */ /*GNU Hurd fragmentation bug*/
 
 #define RELOC_H "elf32_i386_reloc.h"
 
 #define NEED_STACK_CHK_GUARD
 
 #undef HAVE_D_TYPE /*FIXME defined, but not implemented in readdir*/
-#define NO_FILE_LOCKING /*FIXME*/
+/* #define NO_FILE_LOCKING */ /*FIXME*/
+
+#define INITIALIZE_BRK							\
+  massert(!brk(gcl_alloc_initialized ? core_end :			\
+	       ({extern ufixnum _end;(void *)ROUNDUP((ufixnum)&_end,PAGESIZE);})))
+
--- /dev/null
+++ gcl27-2.7.0/h/amd64-gnu.h
@@ -0,0 +1,68 @@
+#include "linux.h"
+
+#ifdef IN_GBC
+/*  #undef MPROTECT_ACTION_FLAGS */
+/*  #define MPROTECT_ACTION_FLAGS SA_RESTART|SA_SIGINFO */
+/*  #define GET_FAULT_ADDR(sig,code,sv,a) \ */
+/*   ((siginfo_t *)code)->si_addr */
+/* the following two files have changed back
+   and forth in recent versions of linux...
+   Include both if they both exist, otherwise
+   include whatever one exists...
+   basically one wants the
+   struct sigcontext_struct { ... } ;
+   so as to get the fault address.
+   */
+
+#if !defined(SIGNAL_H_HAS_SIGCONTEXT) && !defined(HAVE_SIGCONTEXT)
+#error Need sigcontext on 386 linux
+#else
+#include <signal.h>
+#ifndef SIGNAL_H_HAS_SIGCONTEXT
+#ifdef  HAVE_ASM_SIGCONTEXT_H
+#include <asm/sigcontext.h>
+#endif
+#ifdef  HAVE_ASM_SIGNAL_H
+#include <asm/signal.h>
+#endif
+#endif
+#endif
+
+#undef MPROTECT_ACTION_FLAGS
+#define MPROTECT_ACTION_FLAGS SA_RESTART|SA_SIGINFO
+#ifndef SA_SIGINFO
+#define GET_FAULT_ADDR(sig,code,sv,a) ((char *)code)
+#define SA_SIGINFO 0
+#else
+#define GET_FAULT_ADDR(sig,code,sv,a) ((siginfo_t *)code)->si_addr
+#endif
+/* #define GET_FAULT_ADDR(sig,code,sv,a) ((void *)(((struct sigcontext *)(&code))->cr2)) */
+#endif
+
+/*#define NULL_OR_ON_C_STACK(x) ((x)==0 || ((unsigned int)x) > (unsigned int)(pagetochar(MAXPAGE+1)))*/
+
+#define ADDITIONAL_FEATURES \
+		     ADD_FEATURE("BSD386"); \
+      	             ADD_FEATURE("MC68020")
+
+
+#define	I386
+#define SGC
+
+#ifndef SA_NOCLDWAIT
+#define SA_NOCLDWAIT 0 /*fixme handler does waitpid(-1, ..., WNOHANG)*/
+#endif
+#define PATH_MAX 4096 /*fixme dynamic*/
+#define MAXPATHLEN 4096 /*fixme dynamic*/
+/* #define MAX_BRK 0x70000000 */ /*GNU Hurd fragmentation bug*/
+
+#define RELOC_H "elf64_i386_reloc.h"
+
+#define NEED_STACK_CHK_GUARD
+
+#undef HAVE_D_TYPE /*FIXME defined, but not implemented in readdir*/
+/* #define NO_FILE_LOCKING */ /*FIXME*/
+
+#define INITIALIZE_BRK							\
+  massert(!brk(gcl_alloc_initialized ? core_end :			\
+	       ({extern ufixnum _end;(void *)ROUNDUP((ufixnum)&_end,PAGESIZE);})))
--- gcl27-2.7.0.orig/h/gnuwin95.defs
+++ gcl27-2.7.0/h/gnuwin95.defs
@@ -39,8 +39,8 @@ SFASL	= sfasl.o
 
 #MPFILES= $(MPDIR)/mpi-386-winnt.o   $(MPDIR)/libmport.a
 #MPFILES= $(MPDIR)/mpi.o   $(MPDIR)/libmport.a
-FIRST_FILE=$(ODIR)/firstfile.o
-LAST_FILE=$(ODIR)/lastfile.o
+FIRST_FILE=firstfile.o
+LAST_FILE=lastfile.o
 
 
 
--- gcl27-2.7.0.orig/h/gnuwin95.h
+++ gcl27-2.7.0/h/gnuwin95.h
@@ -60,16 +60,7 @@ extern DBEGIN_TY _dbegin;
 
 #define TO_NUMBER(ptr,type) (*((type *)(void *)(ptr)))
 
-#define SEEK_TO_END_OFILE(fp) do { struct filehdr fileheader; int i; \
-        fseek(fp,0,0) ; \
-	fread(&fileheader, sizeof(fileheader), 1, fp); \
-	fseek(fp,    fileheader.f_symptr+fileheader.f_nsyms*SYMESZ, 0); \
-	fread(&i, sizeof(i), 1, fp); \
-	fseek(fp, i - sizeof(i), 1); \
-	while ((i = getc(fp)) == 0) \
-		; \
-	ungetc(i, fp); \
-    } while (0)
+#define SEEK_TO_END_OFILE(fp) seek_to_end_ofile(fp)
 		
 #define RUN_PROCESS
 
--- gcl27-2.7.0.orig/h/linux.h
+++ gcl27-2.7.0/h/linux.h
@@ -10,25 +10,7 @@
 
 /* Seeking to the end of ELF data is a little messy... */
 #include <link.h>
-#define SEEK_TO_END_OFILE(fp)\
-  do { \
-	long offset = 0, endofelf; int j; \
-	ElfW(Ehdr) eheader; ElfW(Shdr) shdr; \
-        fseek(fp, 0, SEEK_SET); \
-        massert(1==fread(&eheader, sizeof(eheader), 1, fp));	      \
-  /* in case the headers themselves come AFTER the actual sections */ \
-	endofelf=offset = eheader.e_shoff+ eheader.e_shentsize *eheader.e_shnum;\
-        fseek(fp, eheader.e_shoff, SEEK_SET); \
-	if ( eheader.e_shentsize != sizeof(ElfW(Shdr)) ) \
-	  { FEerror("Bad ELF section header size",0); } \
-        for ( j = 0; j < eheader.e_shnum; j++ ) \
-	  { massert(1==fread(&shdr,eheader.e_shentsize,1,fp));		\
-            if ( (shdr.sh_offset > offset) && (shdr.sh_type != SHT_NOBITS) ) \
-	      { offset = shdr.sh_offset; endofelf = offset+shdr.sh_size; } \
-	  } \
-	if ( fseek(fp, endofelf, SEEK_SET) ) \
-	    FEerror("Bad ELF file",0); \
-      } while(0)
+#define SEEK_TO_END_OFILE(fp) seek_to_end_ofile(fp)
 
 
 #define GET_FAULT_ADDR(sig,code,sv,a) ((siginfo_t *)code)->si_addr
--- gcl27-2.7.0.orig/h/lu.h
+++ gcl27-2.7.0/h/lu.h
@@ -149,10 +149,13 @@ struct character {
 
   object            ch_name;
   ufixnum           pad5;
-  uchar             ch_code;
+  uchar             ch_code;/*need address of this*/
   uchar             ch_font;
   uchar             ch_bits;
-  ufixnum           pad:LM(24);
+  uchar             cp1;/*cygwin won't take a bit field pad here*/
+#if SIZEOF_LONG == 8
+  uchar             cp2,cp3,cp4,cp5;
+#endif
   ufixnum           pad1;
   ufixnum           pad2;
   ufixnum           pad3;
--- gcl27-2.7.0.orig/h/mach64_i386_reloc.h
+++ gcl27-2.7.0/h/mach64_i386_reloc.h
@@ -6,7 +6,7 @@
   case X86_64_RELOC_UNSIGNED:		// for absolute addresses
 
      if (ri->r_extern || !ri->r_pcrel) 
-      add_val(q,~0L,ri->r_pcrel ? a-rel : a);
+      store_val(q,~0L,ri->r_pcrel ? a-rel : a);
 
     break; 
   case X86_64_RELOC_GOT_LOAD:		// a MOVQ load of a GOT entry
--- gcl27-2.7.0.orig/h/mingw.h
+++ gcl27-2.7.0/h/mingw.h
@@ -107,16 +107,7 @@ extern DBEGIN_TY _stacktop, _stackbottom
 
 #define TO_NUMBER(ptr,type) (*((type *)(void *)(ptr)))
 
-#define SEEK_TO_END_OFILE(fp) do { struct filehdr fileheader; int i; \
-        fseek(fp,0,0) ; \
-        fread(&fileheader, sizeof(fileheader), 1, fp); \
-	fseek(fp,    fileheader.f_symptr+fileheader.f_nsyms*SYMESZ, 0); \
-	fread(&i, sizeof(i), 1, fp); \
-	fseek(fp, i - sizeof(i), 1); \
-	while ((i = getc(fp)) == 0) \
-		; \
-        ungetc(i, fp); \
-    } while (0)
+#define SEEK_TO_END_OFILE(fp) seek_to_end_ofile(fp)
 		
 #define	IEEEFLOAT
 #define I386
--- gcl27-2.7.0.orig/h/protoize.h
+++ gcl27-2.7.0/h/protoize.h
@@ -1671,3 +1671,5 @@ object funcall_cfun(void(*)(),int,...);
 int gcl_init_cmp_anon(void);
 int is_bigger_fixnum(void *);
 int is_text_addr(void *);
+int seek_to_end_ofile(FILE *);
+void stack_list(void);
--- gcl27-2.7.0.orig/lsp/gcl_arraylib.lsp
+++ gcl27-2.7.0/lsp/gcl_arraylib.lsp
@@ -117,6 +117,7 @@
 		     ,(case x
 			(character `(code-char (*uchar (c-array-self a) i t (char-code v))))
 			(bit `(set-0-byte-array-self v a i))
+			((t) `(,(caddr y) (c-array-self a) i a v))
 			(otherwise `(,(caddr y) (c-array-self a) i t v)))))
 		 +array-type-info+)))
 (setf (get 'row-major-aset 'compiler::consider-inline) t)
@@ -497,7 +498,7 @@
 	 (off (ash pos (min 0 (- (1- (third l))))))
 	 (cp (eq (car l) 'character)))
     (flet ((fm (x y)
-	     (let* ((res `(,(fifth l) (c-strstd-sself ,x) ,off ,(when y t) ,y))
+	     (let* ((res `(,(fifth l) (c-strstd-sself ,x) ,off ,(when y (if (eq '*object (fifth l)) x t)) ,y))
 		    (res (if cp `(code-char ,res) res)))
 	       (if (unless (eq tp t) tp) `(the ,tp ,res) res))))
       (if vp
--- gcl27-2.7.0.orig/lsp/gcl_deftype.lsp
+++ gcl27-2.7.0/lsp/gcl_deftype.lsp
@@ -8,7 +8,7 @@
 	  positive-float non-positive-float non-negative-float negative-real
 	  positive-real non-positive-real non-negative-real complex*
 	  complex-integer complex-integer-ratio complex-ratio-integer seqind seqbnd
-	  complex-ratio complex-short-float complex-long-float make-complex));FIXME
+	  complex-ratio complex-short-float complex-long-float make-complex unordered));FIXME
 
 (defun default-to-* (x)
   (let* ((z (member-if (lambda (x) (member x lambda-list-keywords)) x))
@@ -301,11 +301,14 @@
 (deftype ratio (&whole w &optional low high)
   (bnd-exp 'ratio w low high))
 
-(deftype short-float (&whole w &optional low high)
-  (bnd-exp 'short-float w low high))
-
-(deftype long-float (&whole w &optional low high)
-  (bnd-exp 'long-float w low high))
+(deftype short-float (&whole w &optional low (high '* hp))
+  (if (and (eq low 'unordered) (not hp)) w ;This unnecessary extension is simpler than
+                                           ;(and short-float (not (or (short-float 0) (short-float * 0))))
+      (bnd-exp 'short-float w low high)))
+
+(deftype long-float (&whole w &optional low (high '* hp))
+  (if (and (eq low 'unordered) (not hp)) w
+      (bnd-exp 'long-float w low high)))
 
 
 (deftype zero nil `(integer 0 0))
@@ -396,24 +399,17 @@
 
 (deftype complex (&optional rp) `(complex* ,rp))
 
+(defun ncs (rp &aux (rp (if (eq rp '*) 'real rp)))
+  (mapcar (lambda (x) (cons x (car (resolve-type `(and ,x ,rp))))) +range-types+))
+
 (defun make-complex* (r i)
-  (when (and (cdr r) (cdr i)) `((complex* ,(?or (cdr r)) ,(?or (cdr i))))))
+  (when (and (cdr r) (cdr i)) `((complex* ,(cdr r) ,(cdr i)))))
 
-(defun group-real-types (y)
-  (mapcar (lambda (x)
-	    (cons x (lremove-if-not (lambda (y) (eq x (if (eq (car y) 'or) (caadr y) (car y)))) y)))
-	  +range-types+))
-
-(deftype complex* (&optional rp (ip rp)
-			  &aux (r (nc (if (eq rp '*) 'real rp)))
-			  (i (nc (if (eq ip '*) 'real ip))));FIXME upgraded
-  (let* ((qr (group-real-types r))
-	 (qi (group-real-types i))
-	 (x (?or (nconc
-		  (make-complex* (assoc 'integer qr) (assoc 'ratio qi))
-		  (make-complex* (assoc 'ratio qr) (assoc 'integer qi))
-		  (mapcan (lambda (x) (make-complex* (assoc x qr) (assoc x qi)))  +range-types+)))))
-    x))
+(deftype complex* (&optional rp (ip rp) &aux (rr (ncs rp))(ri (ncs ip)));FIXME upgraded
+  (?or (nconc
+	(make-complex* (assoc 'integer rr) (assoc 'ratio ri))
+	(make-complex* (assoc 'ratio rr) (assoc 'integer ri))
+	(mapcan (lambda (x) (make-complex* (assoc x rr) (assoc x ri)))  +range-types+))))
 ;; &whole w
 ;; (if (or (equal w x) (member w x :test 'equal));FIXME
 ;; 	w x)))
@@ -478,8 +474,8 @@
 
 
 (defun all-eq (x y)
-  (mapc (lambda (x y) (unless (eq x y) (return-from all-eq nil))) x y)
-  t)
+  (cond ((not (and x y)) t)
+	((eq (car x) (car y)) (all-eq (cdr x) (cdr y)))))
 
 (defun and-or-norm (op w r &aux (n (mapcar 'normalize-type r)))
   (if (all-eq r n) w (cons op n)))
--- gcl27-2.7.0.orig/lsp/gcl_dl.lsp
+++ gcl27-2.7.0/lsp/gcl_dl.lsp
@@ -5,7 +5,7 @@
 
 (defun lib-name (p)
   (if (or (string= p "") (string= p "libc") (string= p "libm")) "" 
-    (string-concatenate #+darwin "/usr/lib/system/" p #+darwin ".dylib" #-darwin ".so")));FIXME
+    (string-concatenate #+darwin "/usr/lib/system/" p #+darwin ".dylib" #+cygwin ".dll" #-(or darwin cygwin) ".so")));FIXME
 
 (defun mdl (n p vad)
   (let* ((sym (mdlsym n (lib-name p)))
--- gcl27-2.7.0.orig/lsp/gcl_hash.lsp
+++ gcl27-2.7.0/lsp/gcl_hash.lsp
@@ -79,8 +79,8 @@
     (when (>= (1+ n) (c-hashtable-max_ent h))
       (extend-hashtable h))
     (let ((e (gethash-int k h)))
-      (when (eql +objnull+ (htent-key e));FIXME GBC
-	(c-set-hashtable-nent h (1+ n)))
+      ;touch hashtable header; ;FIXME GBC
+      (c-set-hashtable-nent h (if (eql +objnull+ (htent-key e)) (1+ n) n))
       (set-htent-key e (address k))
       (set-htent-value e v))))
 (setf (get 'hash-set 'compiler::cmp-inline) t)
--- gcl27-2.7.0.orig/lsp/gcl_listlib.lsp
+++ gcl27-2.7.0/lsp/gcl_listlib.lsp
@@ -44,28 +44,48 @@
 		   ((endp f) (return (1+ (- (+ i i)))))
 		   ((endp (cdr f)) (return (- (+ i i))))))))))
 
-
+#.(let (r)
+    (labels
+	((f (n r) (when (plusp n) (cons `(pop ,r) (f (1- n) r))))
+	 (d (n &aux (s (intern (format nil "AFC~a" n))))
+	   (setq r (cons (cons n s) r))
+	   `(progn (declaim (inline ,s))
+		   (defun ,s (f s r)
+		     (declare (function f)(proper-list r))
+		     (values (funcall f s ,@(f n 'r))))))
+	 (a (n) (when (plusp n) (cons (d n) (a (1- n))))))
+      `(progn
+	 ,@(a (- call-arguments-limit 2))
+	 (defconstant +afc-syms+ ',r))))
+
+(declaim (inline afc-sym))
+(defun afc-sym (n)
+  (labels ((f (n s) (when s (if (eql (caar s) n) (cdar s) (f n (cdr s))))))
+    (f n +afc-syms+)))
 
 (defun mapl (fd list &rest r &aux (fun (coerce fd 'function)))
   (declare (optimize (safety 1))(dynamic-extent r)(notinline make-list));FIXME
   (check-type fd function-designator)
   (check-type list proper-list)
-  (let ((q (when r (make-list (length r)))))
-    (declare (dynamic-extent q))
-    (labels ((a-cons (x) (check-type x list) (or x (return-from mapl list)))
-	     (lmap (f x) (when x (funcall f x) (lmap f (cdr x))))
-	     (lmapr (f x) (lmap f x) x)
-	     (last nil (lmapr (lambda (x) (rplaca x (if r (a-cons (pop r)) (a-cons (cdar x))))) q)))
-      (lmapr (lambda (x) (apply fun x (last))) list))))
+  (labels ((lmap (f x) (when x (funcall f x) (lmap f (cdr x))))
+	   (lmapr (f x) (lmap f x) x))
+    (if (not r) (lmapr fun list);compiler accelerator
+	(let* ((lr (length r))(q (make-list lr))(nf (afc-sym lr)))
+	  (declare (dynamic-extent q))
+	  (labels ((a-cons (x) (check-type x list) (or x (return-from mapl list)))
+		   (last nil (lmapr (lambda (x) (rplaca x (if r (a-cons (pop r)) (a-cons (cdar x))))) q)))
+	    ;cannot apply as fun might capture (last) via &rest
+	    (lmapr (lambda (x) (funcall nf fun x (last))) list))))))
 
 
 (defun mapc (fd list &rest r &aux (fun (coerce fd 'function)))
   (declare (optimize (safety 1))(dynamic-extent r))
   (check-type fd function-designator)
   (check-type list proper-list)
-  (let ((q (when r (make-list (length r)))))
-    (declare (dynamic-extent q))
-    (apply 'mapl (lambda (x &rest r) (apply fun (car x) (mapl (lambda (x) (setf (car x) (car (pop r)))) q))) list r)))
+  (if (not r) (mapl (lambda (x) (funcall fun (car x))) list);compiler accelerator
+      (let* ((lr (length r))(q (make-list lr))(nf (afc-sym lr)))
+	(declare (dynamic-extent q))
+	(apply 'mapl (lambda (x &rest r) (funcall nf fun (car x) (mapl (lambda (x) (setf (car x) (car (pop r)))) q))) list r))))
 
 
 (defun mapcar (fd list &rest r &aux (fun (coerce fd 'function)) res rp)
--- gcl27-2.7.0.orig/lsp/gcl_numlib.lsp
+++ gcl27-2.7.0/lsp/gcl_numlib.lsp
@@ -244,3 +244,36 @@
 
 (dolist (l '(integer-decode-float decode-float scale-float));float-radix float-digits float-precision float-sign
   (setf (get l 'type-propagator) 'atomic-tp-propagator (get l 'compiler::c1no-side-effects) t))
+
+(declaim (inline fryi))
+(defun fryi (x a)
+  (labels ((fryn (x a) (abs (- (* x (denominator a)) (numerator a))))
+	   (fryk (x a b &aux (c (fryn x a))(d (fryn x b))
+		    (kf 0.8);heuristic guard against overshoot
+		    (cf (* c kf))(df (* d kf)))
+	     (cond ((> cf d 0) (values (truncate (/ cf d))))
+		   ((> df c 0) (values (truncate (/ df c))))
+		   (1)))
+	   (med (a b k)
+	     (/ (+ (numerator a)   (* k (numerator b)))
+		(+ (denominator a) (* k (denominator b)))))
+	   (fry (x a b)
+	     (cond ((= (float a x) x) a)
+		   ((= (float b x) x) b)
+		   ((< (med a b 1) x) (fry x (med a b (fryk x a b)) b))
+		   ((fry x a (med b a (fryk x a b)))))))
+    (fry x a (1+ a))))
+
+(defun rationalize (x)
+  (declare (optimize (safety 1)))
+  (check-type x real)
+  (typecase x
+    (rational x)
+    (float
+     (if (isnan x)
+	 (rational x)
+	 (multiple-value-bind
+	       (f r) (truncate x)
+	   (cond ((minusp r) (fryi x (1- f)))
+		 ((zerop r) f)
+		 ((fryi x f))))))))
--- gcl27-2.7.0.orig/lsp/gcl_predlib.lsp
+++ gcl27-2.7.0/lsp/gcl_predlib.lsp
@@ -315,25 +315,14 @@
 		 (if ft res (values (funcall f))))))
 	  (rl l)))
 
-
-;EARLY
-(defun rational (x);FIXME different file -- bootstrap
+(defun rational (x)
   (declare (optimize (safety 1)))
-;  (check-type x real) FIXME
-  (cond ((floatp x)
-	 (multiple-value-bind
-	  (i e s) (integer-decode-float x)
-	  (let ((x (if (>= e 0) (ash i e) (/ i (ash 1 (- e))))))
-	    (if (>= s 0) x (- x)))))
-	((rationalp x) x)
-	((error 'type-error :datum x :expected-type 'real))
-	))
-(setf (symbol-function 'rationalize) (symbol-function 'rational))
-
-
-(defun nc (x)
-  (let ((x (car (resolve-type x))))
-    (if (when (listp x) (eq (car x) 'or)) (cdr x) (list x))))
+  (check-type x real)
+  (if (rationalp x) x ;too early for typecase
+      (multiple-value-bind
+	    (i e s) (integer-decode-float x)
+	(let ((x (if (>= e 0) (ash i e) (/ i (ash 1 (- e))))))
+	  (if (>= s 0) x (- x))))))
 
 (defun ordered-intersection-eq (l1 l2)
   (let (z zt)
--- gcl27-2.7.0.orig/lsp/gcl_s.lsp
+++ gcl27-2.7.0/lsp/gcl_s.lsp
@@ -61,18 +61,22 @@
     `(progn
        ,@(mapcar (lambda (z &aux (x (pop z))(s (pop z))(m (car z))(n (intern (string-concatenate "*" (string-upcase x)))))
 		   `(idefun ,n (x o s y)
-			    (declare (fixnum x o)(boolean s))
-			    ,(if (when (eq n '*fixnum) (member :sparc64 *features*));Possibly unaligned access
-				 `(if s
-				      ;FIXME there does not appear any useful way to lift thie branch into lisp for possible branch elimination
-				      (lit :fixnum "((" (:fixnum x) "&(sizeof(fixnum)-1)) ? "
-					   "({fixnum _t=" (:fixnum y) ";unsigned char *p1=(void *)(((fixnum *)" (:fixnum x) ")+" (:fixnum o) "),*p2=(void *)&_t,*pe=p1+sizeof(fixnum);for (;p1<pe;) *p1++=*p2++;_t;}) : "
-					   "({((fixnum *)" (:fixnum x) ")[" (:fixnum o) "]=" (:fixnum y) ";}))")
-				      (lit :fixnum "((" (:fixnum x) "&(sizeof(fixnum)-1)) ? "
-					   "({fixnum _t;unsigned char *p1=(void *)(((fixnum *)" (:fixnum x) ")+" (:fixnum o) "),*p2=(void *)&_t,*pe=p1+sizeof(fixnum);for (;p1<pe;) *p2++=*p1++;_t;}) : "
-					   "((fixnum *)" (:fixnum x) ")[" (:fixnum o) "])"))
-				 `(if s (lit ,x "(((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]=" (,x y) ")")
-				      (lit ,x "((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]")))))
+			    (declare (fixnum x o) ,@(unless (eq n '*object) `((boolean s))))
+			    ,(cond ((when (eq n '*fixnum) (member :sparc64 *features*));Possibly unaligned access
+				    `(if s
+					;FIXME there does not appear any useful way to lift thie branch into lisp for possible branch elimination
+					 (lit :fixnum "((" (:fixnum x) "&(sizeof(fixnum)-1)) ? "
+					      "({fixnum _t=" (:fixnum y) ";unsigned char *p1=(void *)(((fixnum *)" (:fixnum x) ")+" (:fixnum o) "),*p2=(void *)&_t,*pe=p1+sizeof(fixnum);for (;p1<pe;) *p1++=*p2++;_t;}) : "
+					      "({((fixnum *)" (:fixnum x) ")[" (:fixnum o) "]=" (:fixnum y) ";}))")
+					 (lit :fixnum "((" (:fixnum x) "&(sizeof(fixnum)-1)) ? "
+					      "({fixnum _t;unsigned char *p1=(void *)(((fixnum *)" (:fixnum x) ")+" (:fixnum o) "),*p2=(void *)&_t,*pe=p1+sizeof(fixnum);for (;p1<pe;) *p2++=*p1++;_t;}) : "
+					      "((fixnum *)" (:fixnum x) ")[" (:fixnum o) "])")))
+				   ((eq n '*object);sgc header touch support
+				    `(if (eq s t) (lit ,x "(((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]=" (,x y) ")")
+					 (if s (lit ,x "({" (:object s) "->d.e=1;(((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]=" (,x y) ");})")
+					     (lit ,x "((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]"))))
+				   (`(if s (lit ,x "(((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]=" (,x y) ")")
+					 (lit ,x "((" ,(strcat x) "*)" (:fixnum x) ")[" (:fixnum o) "]"))))))
 		 +ks+)))
   (defmacro mfff nil
    `(progn
--- gcl27-2.7.0.orig/lsp/gcl_seq.lsp
+++ gcl27-2.7.0/lsp/gcl_seq.lsp
@@ -125,11 +125,6 @@
 	      (,l tmp ,x);Can't be mapl, used by
 	     tmp)))
 
- ;; (defmacro seqend (seq seqs &aux (l (locsym 'seqend "-LOOP"))(ll (locsym 'seqend "-LOOP")))
- ;;   `(labels ((,ll (x) (if (listp x) array-dimension-limit (length x)))
- ;; 	     (,l (s z) (if s (,l (cdr s) (min (,ll (car s)) z)) z)))
- ;; 	    (,l ,seqs (length ,seq))))
- 
  (defmacro seqval (seq place i)
    `(if (listp ,seq) (pop ,place) (aref ,seq ,i)))
 
@@ -143,36 +138,18 @@
   (check-type rt type-spec)
   (check-type f function-designator)
   (check-type seq sequence)
-  (labels ((ml (i xp seq ns vals) 
-	       (unless (>= i sl)
-		 (let ((tmp (apply f (if l (car seq) (aref seq i)) (seqvals vals ns i))))
-		   (when rt (if lx (setf (car xp) tmp) (setf (aref x i) tmp))))
-		 (ml (1+ i) (cdr xp) (if l (cdr seq) seq) ns vals))))
-	  (ml 0 (when (consp x) x) seq (dyncpl sqs) (dyncpl sqs)) x))
-
-;; (defun map (rt f seq &rest sqs &aux (f (tofn f)) (l (listp seq)) (sl (seqend seq sqs))(x (when rt (make-sequence rt sl))))
-;;   (declare (optimize (safety 2)) (dynamic-extent sqs))
-;;   (check-type rt type-spec)
-;;   (check-type f fn)
-;;   (check-type seq sequence)
-;;   (labels ((ml (i xp seq ns vals) 
-;; 	       (unless (or (>= i sl) (when l (endp seq)) (member-if (lambda (x) (when (listp x) (endp x))) ns))
-;; ;	       (when (and (< i sl) (if l (not (endp seq)) t) (not (member-if (lambda (x) (when (listp x) (endp x))) ns)))
-;; 		 (let ((tmp (apply f (if l (car seq) (aref seq i)) (seqvals vals ns i))))
-;; 		   (cond (xp (setf (car xp) tmp)) (rt (setf (aref x i) tmp))))
-;; 		 (ml (1+ i) (cdr xp) (if l (cdr seq) seq) ns vals))))
-;; 	  (ml 0 (when (consp x) x) seq (dyncpl sqs) (dyncpl sqs)) x))
-
-;; (defun map (rt f seq &rest sqs &aux (seqs (cons seq sqs)) (l (length seqs)) (vals (make-list l)))
-;;   (declare (optimize (safety 2)))
-;;   (declare (:dynamic-extent sqs seqs vals))
-;;   (let ((sl (reduce (lambda (y x) (min y (length x))) seqs :initial-value array-dimension-limit)))
-;;     (do* ((x (when rt (make-sequence rt sl)))(xc (consp x))(xp x)(i 0 (1+ i)))
-;; 	 ((or (when xc (endp xp)) (>= i sl)) x)
-;; 	 (mapl (lambda (x y &aux (z (car x)))
-;; 		 (setf (car y) (if (listp z) (pop (car x)) (aref z i)))) seqs vals)
-;; 	 (let ((tmp (apply f vals)))
-;; 	   (cond (xc (setf (car xp) tmp xp (cdr xp))) (rt (setf (aref x i) tmp)))))))
+  (labels ((lp (fn i xp seq) ;(print (list fn i xp seq))
+	     (unless (>= i sl)
+	       (let ((tmp (funcall fn i seq)))
+		 (when rt (if lx (setf (car xp) tmp) (setf (aref x i) tmp))))
+	       (lp fn (1+ i) (cdr xp) (if l (cdr seq) seq)))))
+    (if sqs
+	(let* ((ns (dyncpl sqs))(vals (dyncpl sqs))(nf (when sqs (afc-sym (length sqs)))))
+	  (lp (lambda (i seq) (funcall nf f (if l (car seq) (aref seq i)) (seqvals vals ns i)))
+	      0 (when (consp x) x) seq))
+	(lp (lambda (i seq) (funcall f (if l (car seq) (aref seq i))))
+	    0 (when (consp x) x) seq))
+    x))
 
 (defun map-into (rs g &rest seqs &aux 
 		    (h rs) (lp (unless (listp rs) (array-total-size rs))) 
--- gcl27-2.7.0.orig/lsp/gcl_subtypep.lsp
+++ gcl27-2.7.0/lsp/gcl_subtypep.lsp
@@ -52,12 +52,14 @@
   (defconstant +atps+ (mapcar (lambda (x) (list x (intern (string-concatenate "ARRAY-"   (string x))))) +array-types+));FIXME
 
   (defconstant +k-ops+
-    `((integer int^ int~ rng-recon)
-      ((ratio short-float long-float) rng^ rng~ rng-recon)
-      (complex-integer cmpi^ cmpi~ cmp-recon)
+    `((integer int^ int~ urng-recon)
+      (ratio   rng^ rng~ urng-recon)
+      ((short-float long-float) urng^ urng~ urng-recon)
+      (complex-integer       cmpi^  cmpi~  cmp-recon)
       (complex-integer-ratio cmpir^ cmpir~ cmp-recon)
       (complex-ratio-integer cmpri^ cmpri~ cmp-recon)
-      ((complex-ratio complex-short-float complex-long-float) cmp^ cmp~ cmp-recon)
+      (complex-ratio         cmpr^  cmpr~  cmp-recon)
+      ((complex-short-float complex-long-float) cmp^ cmp~ cmp-recon)
       ((std-instance structure funcallable-std-instance) std^ std~ std-recon)
       ((proper-cons improper-cons) cns^ cns~ cns-recon)
       (,(mapcar 'cdr *all-array-types*) ar^ ar~ ar-recon)
@@ -204,7 +206,7 @@
 
 
 
-(defun range-cons (range &aux (a (pop range))(d (car range)))
+(defun range-cons (range &aux (a (pop range))(a (or (eq a 'unordered) a))(d (car range)))
   (if (and (eq '* a) (eq '* d)) t (cons a d)))
 
 (defun rngnum (x)
@@ -217,11 +219,19 @@
 
 (defun ncons (a d &aux (na (rngnum a))(nd (rngnum d)))
   (when (or (eq a '*) (eq d '*) (< na nd) (and (eql a d) (eql na nd) (eql a na)))
-    (if (and (eq a '*) (eq d '*)) t (cons a d))))
+    (cons a d)))
 
 (defun rng^ (x y)
   (ncons (rngcmp (car x) (car y) '<) (rngcmp (cdr x) (cdr y) '>)))
 
+(defun unord^ (x y &aux (cx (car x))(cy (car y))
+		     (z (if (eq cx t) cy (if (eq cy t) cx (rd^ cx cy)))))
+  (when z (list z)))
+
+(defun urng^ (x y)
+  (cond ((and (cdr x) (cdr y)) (rng^ x y))
+	((and (null (cdr x)) (null (cdr y))) (unord^ x y))))
+
 (defun rngi (x)
   (if (listp x) (if (integerp (car x)) x (car x)) (list x)))
 
@@ -230,38 +240,63 @@
 	((eq (cdr x) '*) (list (cons '* (rngi (car x)))))
 	((nconc (rng~ (cons (car x) '*)) (rng~ (cons '* (cdr x)))))))
 
+(defun unord~ (x &aux (cx (car x)))
+  (unless (eq cx t)
+    (if (listp cx) (mapcar (lambda (x) (list x)) cx) (list (list x)))))
+
+(defun urng~ (x)
+  (cond ((null (cdr x)) (nconc (unord~ x) (list (cons '* '*))))
+	((and (eq (car x) '*) (eq (cdr x) '*)) (list (cons t nil)))
+	((nconc (list (cons t nil)) (rng~ x)))))
+
 (defun rng-ld (type) (list (pop type) (range-cons type)))
 
-(defun rng-recon (x &aux (c (pop x)))
+(defun urng-recon (x &aux (c (pop x)))
   (if (eq (car x) t)
       (list c '* '*)
-      (?or (mapcar (lambda (x) (list c (car x) (cdr x))) x))))
+      (?or (mapcar (lambda (x &aux (o (list c (car x) (cdr x))))
+		     (cond ((and (eq (car x) '*) (eq (cdr x) '*)) `(and ,o (not (,c unordered))))
+			   ((cdr x) o)
+			   ((listp (car x)) `(and (,c unordered) (not (member ,@(car x)))))
+			   ((eq (car x) t) `(,c unordered))
+			   (`(member ,(car x)))))
+		   x))))
   
 
 ;;; COMPLEX
 
-(defun cmp-fk (x) (if (eq (car x) 'or) (caadr x) (car x)))
 
-(defun cmp-k (x y &aux (kx (cmp-fk x))(ky (cmp-fk y)) )
-  (cadr (assoc (if (eq kx ky) kx (list kx ky)) +ctps+ :test 'equal)))
 
-(defun cmp-rng (x)
-  (mapcar (lambda (x) (range-cons (cdr x))) (if (eq (car x) 'or) (cdr x) (list x))))
 
-(defun cmp-rng2 (x y &aux (rx (cmp-rng x))(ry (cmp-rng y)))
-  (or (and (eq (car rx) t) (eq (car ry) t))
-      (cons rx ry)))
 
-(defun cmp-ld (type &aux (rtp (cadr type))(itp (or (caddr type) rtp)))
-  `(,(cmp-k rtp itp) ,(cmp-rng2 rtp itp)))
+
+(defun sking (tp &aux (tp (nprocess-type tp)))
+  (unless (or (cadr tp) (caddr tp) (cdar tp))
+    (caar tp)))
+
+(defun lookup-cmp-k (rk ik)
+  (cadr (assoc (if (eq rk ik) rk (list rk ik))	+ctps+ :test 'equal)))
+
+(defun cmp-k (x y)
+  (lookup-cmp-k (car (sking x)) (car (sking y))))
+
+(defun cmp-ld (type &aux (r (sking (cadr type)))(rk (pop r))
+		      (i (sking (or (caddr type) (cadr type))))(ik (pop i)))
+  (let ((k (lookup-cmp-k rk ik)))
+    (when k
+      `(,k ,(if (and (eq (car r) t) (eq (car i) t)) t (cons r i))))))
+
+(defun irange (x)
+  (if (isnan x) (list x) (cons x x)))
 
 (defun cmp-irange (x &aux (r (realpart x))(i (imagpart x)))
-  `(((,r . ,r)) . ((,i . ,i))))
+  `((,(irange r)) . (,(irange i))))
+
 
 (defun rng-ip (x)
   (unless (cdr x)
     (when (consp (car x))
-      (when (atom (caar x))
+      (when (realp (caar x))
 	(eql (caar x) (cdar x))))))
 
 (defun cmp-cons (a d)
@@ -277,10 +312,11 @@
 	   (nconc (cmp-cons a (cdr x)) (cmp-cons (car x) d) (cmp-cons a d))))
 	((cmpg~ kr ki (cmp-irange x)))))
 
-(defun cmpi~ (x)  (cmpg~ 'integer 'integer x))
-(defun cmpir~ (x) (cmpg~ 'integer 'ratio x))
-(defun cmpri~ (x) (cmpg~ 'ratio   'integer x))
-(defun cmp~ (x)   (cmpg~ 'ratio   'ratio x))
+(defun cmpi~  (x) (cmpg~ 'integer    'integer x))
+(defun cmpir~ (x) (cmpg~ 'integer    'ratio   x))
+(defun cmpri~ (x) (cmpg~ 'ratio      'integer x))
+(defun cmpr~  (x) (cmpg~ 'ratio      'ratio   x))
+(defun cmp~   (x) (cmpg~ 'long-float 'long-float x))
 
 (defun cmpg^ (kr ki x y)
   (cond ((and (consp x) (consp y))
@@ -290,10 +326,11 @@
 	((rd^ x y))))
 
 
-(defun cmpi^ (x y)  (cmpg^ 'integer 'integer x y))
-(defun cmpir^ (x y) (cmpg^ 'integer 'ratio x y))
-(defun cmpri^ (x y) (cmpg^ 'ratio   'integer x y))
-(defun cmp^ (x y)   (cmpg^ 'ratio   'ratio x y))
+(defun cmpi^  (x y) (cmpg^ 'integer    'integer x y))
+(defun cmpir^ (x y) (cmpg^ 'integer    'ratio x y))
+(defun cmpri^ (x y) (cmpg^ 'ratio      'integer x y))
+(defun cmpr^  (x y) (cmpg^ 'ratio      'ratio x y))
+(defun cmp^   (x y) (cmpg^ 'long-float 'long-float x y))
 
 
 (defun cmp-recon (x &optional (c (car (rassoc (pop x) +ctps+ :key 'car)) cp))
@@ -302,8 +339,8 @@
 	((eq x t) (if (consp c) `(complex* (,(pop c) * *) (,(car c) * *))
 		    `(complex (,c * *))))
 	((consp x)
-	 (let* ((rx (rng-recon (cons (if (consp c) (pop c) c) (car x))))
-		(ry (rng-recon (cons (if (consp c) (car c) c) (cdr x)))))
+	 (let* ((rx (k-recon (cons (if (consp c) (pop c) c) (car x))))
+		(ry (k-recon (cons (if (consp c) (car c) c) (cdr x)))))
 	   (if (equal rx ry)
 	       `(complex ,rx)
 	     `(complex* ,rx ,ry))))
@@ -482,7 +519,7 @@
 #.`(defun kmem (x &aux (z (ktype-of x)))
      (case z
 	   ((proper-cons improper-cons) (mcns-ld z x))
-	   (,+range-types+ `(,z (,x . ,x)))
+	   (,+range-types+ `(,z (,x . ,(unless (isnan x) x))))
 	   (null `(,z t))
 	   (otherwise `(,z ,x))))
 
--- gcl27-2.7.0.orig/lsp/gcl_type.lsp
+++ gcl27-2.7.0/lsp/gcl_type.lsp
@@ -55,6 +55,7 @@
 					 (mapcar (lambda (y) (cons x y))
 						 '((* (-1))(-1 -1) ((-1) (0)) (0 0) ((0) (1)) (1 1) ((1) *))))
 				       '(ratio short-float long-float))
+			     short-float long-float
 			     proper-cons improper-cons (vector nil) (array nil);FIXME
 			     ,@(lremove 'gsym (mapcar 'car +r+))))))
 		     (q2 (mapcar
@@ -264,11 +265,9 @@
 
 (defun object-tp1 (x)
   (when *cmp-verbose* (print (list 'object-type x)))
-  (if (isnan x)
-      (cmp-norm-tp (car (member x '(long-float short-float) :test 'typep)));FIXME
-    (let* ((i (object-index x))(z (caddr (svref *btpa* i))))
+  (let* ((i (object-index x))(z (caddr (svref *btpa* i))))
       (if (assoc i *atomic-btp-alist*) z
-	(copy-tp z *nil-tp* (nprocess-type (normalize-type `(member ,x))) 0)))))
+	(copy-tp z *nil-tp* (nprocess-type (normalize-type `(member ,x))) 0))))
 
 (defvar *atomic-type-hash* (make-hash-table :test 'eql))
 
@@ -358,13 +357,14 @@
 	  ((and (eql rm my) (eql rx xy)) y)
 	  ((cons rm rx)))))
 
-(defun rng-bnd (y x) (if y (rng-bnd2 y x) x))
+(defun rng-bnd (y x) (if (cdr x) (if y (rng-bnd2 y x) x) y))
 
 (defvar *btp-bnds*
   (let ((i -1))
     (mapcan (lambda (x)
 	      (incf i)
-	      (when (member (when (listp x) (car x)) +range-types+)
+	      (when (and (member (when (listp x) (car x)) +range-types+)
+			 (caddr x));unordered
 		`((,i ,(cons (cadr x) (caddr x))))))
 	    +btp-types+)))
 
@@ -710,7 +710,7 @@
 				  seqind seqbnd
 				  non-negative-immfix immfix
 				  non-negative-fixnum non-negative-bignum non-negative-integer
-				  tractable-fixnum fixnum bignum integer
+				  tractable-fixnum fixnum bignum integer rational
 				  negative-short-float positive-short-float
 				  non-negative-short-float non-positive-short-float
 				  short-float
--- gcl27-2.7.0.orig/lsp/gcl_typecase.lsp
+++ gcl27-2.7.0/lsp/gcl_typecase.lsp
@@ -23,7 +23,8 @@
 	 (l (if a l (car l)))
 	 (l (unless (eq '* l) l)))
     (when l
-      (if f (if a `((<= ,l ,o)) `((< ,l ,o))) (if a `((<= ,o ,l)) `((< ,o ,l)))))))
+      (if (eq l 'unordered) `((isnan ,o))
+	  (if f (if a `((<= ,l ,o)) `((< ,l ,o))) (if a `((<= ,o ,l)) `((< ,o ,l))))))))
 
 
 (defun ?and-or (op x)
--- gcl27-2.7.0.orig/lsp/gcl_typep.lsp
+++ gcl27-2.7.0/lsp/gcl_typep.lsp
@@ -5,7 +5,7 @@
   (let* ((a (atom l))
 	 (l (if a l (car l)))
 	 (l (unless (eq '* l) l)))
-    (or (not l) (if f (if a (<= l o) (< l o)) (if a (<= o l) (< o l))))))
+    (or (not l) (if (eq l 'unordered) (isnan o) (if f (if a (<= l o) (< l o)) (if a (<= o l) (< o l)))))))
 (setf (get 'ib 'cmp-inline) t)
 
 (defun db (o tp)
--- gcl27-2.7.0.orig/o/alloc.c
+++ gcl27-2.7.0/o/alloc.c
@@ -223,8 +223,11 @@ add_page_to_freelist(char *p, struct typ
      are many arrays in a system to make the headers not writable,
      but just SGC_TOUCH the header each time you write to it.   this
      is what is done with t_structure */
-  if (t==(tm_of(t_array)->tm_type))
-    pp->sgc_flags|=SGC_PERM_WRITABLE;
+  /* if (t==(tm_of(t_array)->tm_type)) */
+  /*   pp->sgc_flags|=SGC_PERM_WRITABLE; */
+  /* The SGC_PERM_WRITABLE facility is no longer used in favor of
+     SGC_TOUCH.  Implicitly grouping object types by size is
+     unreliable.*/
 
 #endif 
 
@@ -1294,6 +1297,10 @@ gcl_init_alloc(void *cs_start) {
 
 #endif
 
+#ifdef INITIALIZE_BRK
+  INITIALIZE_BRK;
+#endif
+
   update_real_maxpage();
 
   if (gcl_alloc_initialized) {
--- gcl27-2.7.0.orig/o/boot.c
+++ gcl27-2.7.0/o/boot.c
@@ -64,9 +64,6 @@ DEFUN("<<",object,fSlshft,SI,2,2,NONE,II
 DEFUN(">>",object,fSrshft,SI,2,2,NONE,II,IO,OO,OO,(fixnum x,fixnum y),"") {
   RETURN1((object)(x>>y));
 }
-DEFUN("POPCOUNTL",object,fSpopcountl,SI,1,1,NONE,II,OO,OO,OO,(fixnum x),"") {
-  RETURN1((object)(fixnum)__builtin_popcountl(x));
-}
 
 static inline bool
 TESTA(object x_,object y_,object key,object test,object test_not) {
--- gcl27-2.7.0.orig/o/cfun.c
+++ gcl27-2.7.0/o/cfun.c
@@ -76,17 +76,29 @@ DEFUN("CFDL",object,fScfdl,SI,0,0,NONE,O
     
 DEFUN("DLSYM",object,fSdlsym,SI,2,2,NONE,OI,OO,OO,OO,(fixnum h,object name),"") {
 
-  char ch;
   void *ad;
 
   dlerror();
   name=coerce_to_string(name);
-  ch=name->st.st_self[VLEN(name)];
-  name->st.st_self[VLEN(name)]=0;
-  ad=dlsym(h ? (void *)h : RTLD_DEFAULT,name->st.st_self);
-  ad=ad ? ad : dlsym(RTLD_DEFAULT,name->st.st_self);
-  ad=is_text_addr(ad) ? dlsym(RTLD_NEXT,name->st.st_self) : ad;
-  name->st.st_self[VLEN(name)]=ch;
+  massert(snprintf(FN1,sizeof(FN1),"%-.*s",VLEN(name),name->st.st_self)>0);
+#ifndef __CYGWIN__
+  ad=dlsym(h ? (void *)h : RTLD_DEFAULT,FN1);
+  ad=ad ? ad : dlsym(RTLD_DEFAULT,FN1);
+  ad=is_text_addr(ad) ? dlsym(RTLD_NEXT,FN1) : ad;
+#else
+  ad=0;
+  if (h) ad=dlsym((void *)h,FN1);
+  {
+    static void *n,*u,*c;
+    n=n ? n : dlopen("ntdll.dll",RTLD_LAZY|RTLD_GLOBAL);
+    u=u ? u : dlopen("ucrtbase.dll",RTLD_LAZY|RTLD_GLOBAL);
+    c=c ? c : dlopen("cygwin1.dll",RTLD_LAZY|RTLD_GLOBAL);
+    ad=ad ? ad : dlsym(n,FN1);
+    ad=ad ? ad : dlsym(u,FN1);
+    ad=ad ? ad : dlsym(c,FN1);
+    ad=ad ? ad : dlsym(RTLD_DEFAULT,FN1);
+  }
+#endif
   if (!ad) {
     char *er=dlerror();
     FEerror("dlsym lookup failure on ~s: ~s",2,name,make_simple_string(er ? er : ""));
@@ -124,19 +136,17 @@ DEFUN("DLADDR",object,fSdladdr,SI,2,2,NO
 
 DEFUN("DLOPEN",object,fSdlopen,SI,1,1,NONE,OO,OO,OO,OO,(object name),"") {
 
-  char ch,*err;
+  char *err;
   void *v;
-  ufixnum i;
 
   dlerror();
   name=coerce_to_string(name);
-  ch=name->st.st_self[VLEN(name)];
-  name->st.st_self[VLEN(name)]=0;
-  i=VLEN(name);
-  if (!strncmp("libc.so",name->st.st_self,i) || !strncmp("libm.so",name->st.st_self,i))
-    i=0;
-   v=dlopen(i ? name->st.st_self : 0,RTLD_LAZY|RTLD_GLOBAL);
-  name->st.st_self[VLEN(name)]=ch;
+  if (!strncmp("libc.so",name->st.st_self,VLEN(name)) || !strncmp("libm.so",name->st.st_self,VLEN(name)))
+    v=dlopen(0,RTLD_LAZY|RTLD_GLOBAL);
+  else {
+    massert(snprintf(FN1,sizeof(FN1),"%-.*s",VLEN(name),name->st.st_self)>0);
+    v=dlopen(FN1,RTLD_LAZY|RTLD_GLOBAL);
+  }
   if ((err=dlerror()))
     FEerror("dlopen failure on ~s: ~s",2,name,make_simple_string(err));
   
--- gcl27-2.7.0.orig/o/eval.c
+++ gcl27-2.7.0/o/eval.c
@@ -786,7 +786,7 @@ call_applyhook(object fun)
 	object ah;
 
 	ah = symbol_value(siVapplyhook);
-	Llist();
+	stack_list();
 	vs_push(vs_base[0]);
 	vs_base[0] = fun;
 	vs_push(list(3,lex_env[0],lex_env[1],lex_env[2]));
--- gcl27-2.7.0.orig/o/file.d
+++ gcl27-2.7.0/o/file.d
@@ -1797,7 +1797,7 @@ LFD(Lmake_broadcast_stream)() {
 				     MMcons(MMcons(sLsatisfies,MMcons(sLoutput_stream_p,Cnil)),Cnil))));
       /* cannot_write(vs_base[i]); */
 
-  Llist();
+  stack_list();
 
   x = alloc_object(t_stream);
   x->sm.tt=x->sm.sm_mode = (short)smm_broadcast;
@@ -1822,7 +1822,7 @@ LFD(Lmake_concatenated_stream)() {
 	!input_stream_p(vs_base[i]))
       cannot_read(vs_base[i]);
 
-  Llist();
+  stack_list();
 
   x = alloc_object(t_stream);
   x->sm.tt=x->sm.sm_mode = (short)smm_concatenated;
--- gcl27-2.7.0.orig/o/funlink.c
+++ gcl27-2.7.0/o/funlink.c
@@ -417,7 +417,7 @@ call_proc_new(object sym,ufixnum clp,ufi
     } else
       vs_top=base;
 
-    for (;--old_top>=vs_top && old_top>=vs_org;) *old_top=Cnil;
+    for (;--old_top>=vs_top && vs_top>=vs_org;) *old_top=Cnil;
     
     switch(result_type) {
     case f_fixnum:
--- gcl27-2.7.0.orig/o/gbc.c
+++ gcl27-2.7.0/o/gbc.c
@@ -666,7 +666,7 @@ mark_object1(object x) {
     mark_object(x->pn.pn_namestring);
     break;
     
-  case t_function:	
+  case t_function:
     mark_object(x->fun.fun_data);
     mark_object(x->fun.fun_plist);
     if (x->fun.fun_env != def_env && x->fun.fun_env != src_env) {
--- gcl27-2.7.0.orig/o/gmp_big.c
+++ gcl27-2.7.0/o/gmp_big.c
@@ -509,7 +509,7 @@ integer_quotient_remainder_1(object x, o
 
   if (type_of(x)==t_fixnum && type_of(y)==t_fixnum) {
     fixnum fx=fix(x),fy=fix(y);
-    if (fx!=-fx) {/*MOST_NEGATIVE_FIX*/
+    if (fx!=MOST_NEGATIVE_FIX) {
       if (qp) {
 	fixnum z=fixnum_div(fx,fy,d);
 	if (rp) *rp=make_fixnum(fx-fy*z);
@@ -521,9 +521,9 @@ integer_quotient_remainder_1(object x, o
   }
 
   {
-    
+
     __mpz_struct *b1=INTEGER_TO_MP(x,big_fixnum1),*b2=INTEGER_TO_MP(y,big_fixnum2);
-    
+
     if (qp) {
       if (rp) {
 	void (*f)()=d<0 ? mpz_fdiv_qr : (d>0 ? mpz_cdiv_qr : mpz_tdiv_qr);
--- gcl27-2.7.0.orig/o/gprof.c
+++ gcl27-2.7.0/o/gprof.c
@@ -52,7 +52,6 @@ gprof_cleanup(void) {
 DEFUN("GPROF-ADDRESSES",object,fSgprof_addresses,SI,0,0,NONE,OO,OO,OO,OO,(void),"") {
 
   void *min=heap_end,*max=data_start,*c;
-  static void *mintext;
   struct pageinfo *v;
   object x;
   fixnum i;
@@ -69,19 +68,15 @@ DEFUN("GPROF-ADDRESSES",object,fSgprof_a
   if (max<min)
     min=max;
 
-  if (!mintext) {/*FIXME min_text*/
-
-    mintext=data_start;
-
 #ifdef GCL_GPROF
-    for (i=0;i<c_table.alloc_length;i++)
-      mintext=(void *)c_table.ptable[i].address<mintext ? (void *)c_table.ptable[i].address : mintext;
-#endif
+  {
+      extern void *min_text;
 
-  }
+      if (min_text<data_start)
+	min=min_text;
 
-  if (mintext<data_start)
-    min=mintext;
+  }
+#endif
 
   return MMcons(make_fixnum((fixnum)min),make_fixnum((fixnum)max));
 
--- gcl27-2.7.0.orig/o/list.d
+++ gcl27-2.7.0/o/list.d
@@ -227,25 +227,52 @@ make_list(fixnum n) {
   return x;
 }
 
-LFD(Llist)() {
+static fixnum
+list_count(fixnum nargs,object first,object l,va_list ap) {
+  fixnum n;
+  for (n=0;NEXT_ARG(nargs,ap,l,first,OBJNULL)!=OBJNULL;n++);
+  return n;
+}
+
+DEFUN("LIST",object,fLlist,LISP,0,MAX_ARGS,NONE,OO,OO,OO,OO,(object first,...),"") {
+
+  object x,l=Cnil;
+  va_list ap;
+  fixnum nargs=INIT_NARGS(0),n;
+
+  va_start(ap,first);
+  n=list_count(nargs,first,l,ap);
+  va_end(ap);
+  va_start(ap,first);
+  x=n_cons(n,NEXT_ARG(nargs,ap,l,first,Cnil),NEXT_ARG(nargs,ap,l,first,Cnil));
+  va_end(ap);
+  RETURN1(x);
 
-  object *a;
+}
 
-  a=vs_base;
-  vs_base[0]=n_cons(vs_top-vs_base,*a++,Cnil);
-  vs_top=vs_base+1;
+DEFUN("LIST*",object,fLlistA,LISP,1,MAX_ARGS,NONE,OO,OO,OO,OO,(object first,...),"") {
+
+  object x,l=Cnil;
+  va_list ap;
+  fixnum nargs=INIT_NARGS(0),n;
+
+  va_start(ap,first);
+  n=list_count(nargs,first,l,ap);
+  va_end(ap);
+  va_start(ap,first);
+  x=n_cons(n-1,NEXT_ARG(nargs,ap,l,first,Cnil),NEXT_ARG(nargs,ap,l,first,Cnil));
+  va_end(ap);
+  RETURN1(x);
 
 }
 
-LFD(LlistA)() {
+void
+stack_list(void) {
 
   object *a;
 
-  if (vs_top == vs_base)
-    too_few_arguments();
-
   a=vs_base;
-  vs_base[0]=n_cons(vs_top-vs_base-1,*a++,vs_head);
+  vs_base[0]=n_cons(vs_top-vs_base,*a++,Cnil);
   vs_top=vs_base+1;
 
 }
@@ -348,7 +375,5 @@ gcl_init_list_function()
 
 	sKinitial_element = make_keyword("INITIAL-ELEMENT");
 
-	make_function("LIST", Llist);
-	make_function("LIST*", LlistA);
 
 }
--- gcl27-2.7.0.orig/o/main.c
+++ gcl27-2.7.0/o/main.c
@@ -271,6 +271,12 @@ get_gc_environ(void) {
     massert(mem_multiple>=0.0);
   }
 
+  log_maxpage_bound=sizeof(fixnum)*8-1;
+  if ((e=getenv("GCL_MEM_BOUND"))) {
+    massert(sscanf(e,"%lud",&log_maxpage_bound)==1);
+    mem_multiple=1.0;
+  }
+
   gc_alloc_min=0.05;
   if ((e=getenv("GCL_GC_ALLOC_MIN"))) {
     massert(sscanf(e,"%lf",&gc_alloc_min)==1);
@@ -341,6 +347,8 @@ update_real_maxpage(void) {
   }
 #endif
 
+  get_gc_environ();
+
 #ifdef DEFINED_REAL_MAXPAGE
   real_maxpage=DEFINED_REAL_MAXPAGE;
 #else
@@ -357,7 +365,6 @@ update_real_maxpage(void) {
 
   phys_pages=ufmin(get_phys_pages1(0)+page(beg),real_maxpage)-page(beg);
 
-  get_gc_environ();
   setup_maxpages(mem_multiple);
 
   return 0;
@@ -423,7 +430,9 @@ void
 init_boot(void) {
 
   char *sysd=getenv("GCL_SYSDIR"),*d=sysd ? sysd : kcl_self;
+#ifndef __CYGWIN__
   void *v,*q;
+#endif
   char *z,*s="libboot.so";
   size_t m=sysd ? strlen(sysd) : dir_name_length(kcl_self),n=m+strlen(s)+1;
   object omp=sSAoptimize_maximum_pagesA->s.s_dbind;
@@ -431,12 +440,21 @@ init_boot(void) {
   sSAoptimize_maximum_pagesA->s.s_dbind=Cnil;
   z=alloca(n);
   snprintf(z,n,"%-*.*s%s",(int)m,(int)m,d,s);
+#ifndef __CYGWIN__
   if (!(v=dlopen(z,RTLD_LAZY|RTLD_GLOBAL)))
     printf("%s\n",dlerror());
   if (!(q=dlsym(v,"gcl_init_boot")))
     printf("%s\n",dlerror());
+#endif
   initializing_boot=1;
+#ifdef __CYGWIN__
+  {
+    extern void gcl_init_boot(void);
+    gcl_init_boot();
+  }
+#else
   ((void (*)())q)();
+#endif
   initializing_boot=0;
   sSAoptimize_maximum_pagesA->s.s_dbind=omp;
 
@@ -884,7 +902,7 @@ ihs_overflow(void) {
 
 void
 segmentation_catcher(int i, long code, void *scp, char *addr) {
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(__CYGWIN__)
   void *faddr;
   faddr=GET_FAULT_ADDR(sig,code,scp,addr); 
 
@@ -1276,7 +1294,7 @@ init_main(void) {
   
 }
 
-#ifdef HAVE_DIS_ASM_H
+#if defined(HAVE_DIS_ASM_H) && defined(OUTPUT_ARCH)
 
 #include "dis-asm.h"
 
--- gcl27-2.7.0.orig/o/num_comp.c
+++ gcl27-2.7.0/o/num_comp.c
@@ -288,7 +288,7 @@ LFD(Lall_different)(void)
 DEFUN("<2",object,fSl2,SI
 	  ,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   
-  RETURN1(number_compare(x,y)<0 ? Ct : Cnil);
+  RETURN1(!gcl_isnan(x) && !gcl_isnan(y) && number_compare(x,y)<0 ? Ct : Cnil);
 
 }
 
@@ -296,7 +296,7 @@ DEFUN("<2",object,fSl2,SI
 DEFUN("<=2",object,fSle2,SI
 	  ,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   
-  RETURN1(number_compare(x,y)<1 ? Ct : Cnil);
+  RETURN1(!gcl_isnan(x) && !gcl_isnan(y) && number_compare(x,y)<1 ? Ct : Cnil);
 
 }
 
@@ -304,7 +304,7 @@ DEFUN("<=2",object,fSle2,SI
 DEFUN(">2",object,fSg2,SI
 	  ,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   
-  RETURN1(number_compare(x,y)>0 ? Ct : Cnil);
+  RETURN1(!gcl_isnan(x) && !gcl_isnan(y) && number_compare(x,y)>0 ? Ct : Cnil);
 
 }
 
@@ -312,7 +312,7 @@ DEFUN(">2",object,fSg2,SI
 DEFUN(">=2",object,fSge2,SI
 	  ,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   
-  RETURN1(number_compare(x,y)>-1 ? Ct : Cnil);
+  RETURN1(!gcl_isnan(x) && !gcl_isnan(y) && number_compare(x,y)>-1 ? Ct : Cnil);
 
 }
 
@@ -320,7 +320,7 @@ DEFUN(">=2",object,fSge2,SI
 DEFUN("=2",object,fSe2,SI
 	  ,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   
-  RETURN1(number_compare(x,y)==0 ? Ct : Cnil);
+  RETURN1(!gcl_isnan(x) && !gcl_isnan(y) && number_compare(x,y)==0 ? Ct : Cnil);
 
 }
 
@@ -328,7 +328,7 @@ DEFUN("=2",object,fSe2,SI
 DEFUN("/=2",object,fSne2,SI
 	  ,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   
-  RETURN1(number_compare(x,y)!=0 ? Ct : Cnil);
+  RETURN1(gcl_isnan(x) || gcl_isnan(y) || number_compare(x,y)!=0 ? Ct : Cnil);
 
 }
 
--- gcl27-2.7.0.orig/o/read.d
+++ gcl27-2.7.0/o/read.d
@@ -2296,6 +2296,7 @@ LFD(Lreadtablep)()
 	check_type_character(&dspchr);
 	check_type_character(&subchr);
 	check_type_readtable(&rdtbl);
+        SGC_TOUCH(rdtbl);
 	if (rdtbl->rt.rt_self[char_code(dspchr)].rte_macro != dispatch_reader
 	    || rdtbl->rt.rt_self[char_code(dspchr)].rte_dtab == NULL)
 		FEerror("~S is not a dispatch character.", 1, dspchr);
--- gcl27-2.7.0.orig/o/sfasli.c
+++ gcl27-2.7.0/o/sfasli.c
@@ -94,14 +94,12 @@ build_symbol_table_bfd(void) {
 
 #endif /* special_rsym */
 
-static void *min_text;
+void *min_text;
 extern void *data_start;
-/* extern char etext,edata,end,_data_start_; */
 
 int
 is_text_addr(void *p) {
   extern int initializing_boot;
-  /* if (!min_text) return 1;/\*FIXME build_symbol_table before initlisp*\/ */
   if (initializing_boot) return 1;/*FIXME*/
   return p>=min_text && p<data_start && !is_bigger_fixnum(p) ? 1 : 0;
 }
@@ -125,7 +123,7 @@ LFD(build_symbol_table)(void) {
   {
     fixnum i;
 
-    min_text=etext;
+    min_text=data_start;
     for (i=0;i<c_table.alloc_length;i++) {
       void *p=(void *)c_table.ptable[i].address;
       min_text=p<min_text ? p : min_text;
--- gcl27-2.7.0.orig/o/sfaslmacho.c
+++ gcl27-2.7.0/o/sfaslmacho.c
@@ -66,14 +66,6 @@ store_val(ul *w,ul m,ul v) {
 
 }
 
-static int
-add_val(ul *w,ul m,ul v) {
-
-  return store_val(w,m,v+(*w&m));
-
-}
-
-
 #ifndef _LP64
 /*redirect trampolines gcc-4.0 gives no reloc for stub sections on x86 only*/
 static int
--- gcl27-2.7.0.orig/o/sgbc.c
+++ gcl27-2.7.0/o/sgbc.c
@@ -673,7 +673,7 @@ sgc_start(void) {
 
   }
 
-  sSAwritableA->s.s_dbind=fSmake_vector(sLbit,(page(rb_start)-first_data_page),Ct,Cnil,Cnil,0,Ct,Cnil);
+  sSAwritableA->s.s_dbind=fSmake_vector(sLbit,(page(heap_end)-first_data_page),Ct,Cnil,Cnil,0,Ct,Cnil);
   wrimap=(void *)sSAwritableA->s.s_dbind->v.v_self;
 
   /* now move the sgc free lists into place.   alt_free should
--- gcl27-2.7.0.orig/o/usig.c
+++ gcl27-2.7.0/o/usig.c
@@ -213,12 +213,12 @@ DEFUN("FPE_CODE",object,fSfpe_code,SI,2,
 #if defined(__MINGW32__) || defined(__CYGWIN__)
 
 DEFUN("FNSTSW",object,fSfnstsw,SI,0,0,NONE,II,OO,OO,OO,(void),"") {
-  volatile unsigned short t;
+  volatile unsigned short t=0;
   ASM ("fnstsw %0" :: "m" (t));
   RETURN1((object)(long)t);
 }
 DEFUN("STMXCSR",object,fSstmxcsr,SI,0,0,NONE,II,OO,OO,OO,(void),"") {
-  volatile unsigned int t;
+  volatile unsigned int t=0;
   ASM ("stmxcsr %0" :: "m" (t));
   RETURN1((object)(long)t);
 }
--- gcl27-2.7.0.orig/pcl/sys-package.lisp
+++ gcl27-2.7.0/pcl/sys-package.lisp
@@ -14,13 +14,13 @@
 ;;; Definitions for package ITERATE of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "ITERATE")
- (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("WALKER" "COMMON-LISP")))
+ (COMMON-LISP::MAKE-PACKAGE "ITERATE" :USE '("COMMON-LISP" "WALKER")))
 
 ;;; Definitions for package PCL of type ESTABLISH
 (COMMON-LISP::UNLESS
  (COMMON-LISP::FIND-PACKAGE "PCL")
  (COMMON-LISP::MAKE-PACKAGE
-  "PCL" :USE '("CSTRUCT" "WALKER" "ITERATE" "COMMON-LISP")))
+  "PCL" :USE '("COMMON-LISP" "ITERATE" "WALKER" "CSTRUCT")))
 
 ;;; Definitions for package SLOT-ACCESSOR-NAME of type EXPORT
 (COMMON-LISP::IMPORT 'COMMON-LISP::NIL "SLOT-ACCESSOR-NAME")
@@ -2133,89 +2133,90 @@
    PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION PCL::LEGAL-DOCUMENTATION-P
    PCL::PRECEDENCE PCL::MAKE-N-N-ACCESSOR-DFUN COMMON-LISP::OTHERWISE
    PCL::.PV-OFFSET. PCL::ACCESSOR-DFUN-INFO-
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LAMBDA-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
-   PCL::|(FAST-WRITER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PLIST)|
    PCL::|(FAST-WRITER-METHOD PLIST-MIXIN PLIST)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PLIST)| PCL::RECORD-DEFINITION
-   PCL::EARLY-GF-P PCL::SPLIT-DECLARATIONS PCL::USE-DISPATCH-DFUN-P
-   PCL::DFUN-INFO-WRAPPER1 PCL::*NORMALIZE-TYPE
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOAD-ENV)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMP-ENV)| PCL::OBJECT-FORM
-   PCL::FUNCALLABLE-STANDARD-OBJECT-SIMPLE-TYPEP-FN
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-WRITER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
+   PCL::RECORD-DEFINITION PCL::EARLY-GF-P PCL::SPLIT-DECLARATIONS
+   PCL::USE-DISPATCH-DFUN-P PCL::DFUN-INFO-WRAPPER1
+   PCL::*NORMALIZE-TYPE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMP-ENV)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOAD-ENV)| PCL::OBJECT-FORM
    PCL::FUNCALLABLE-STANDARD-CLASS-SIMPLE-TYPEP-FN
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFORM)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::FUNCALLABLE-STANDARD-OBJECT-SIMPLE-TYPEP-FN
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFORM)|
    PCL::%STD-INSTANCE- PCL::.QUALIFIERS. PCL::REMOVE-NAMED-METHOD
    PCL::CACHE-FIELD PCL::INSTANCE-SLOTDS PCL::FSC
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT TYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION TYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
-   PCL::GCL_PCL_SLOTS PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::INSTANCE
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION TYPE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT TYPE)| PCL::GCL_PCL_SLOTS
+   PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::INSTANCE
    COMMON-LISP::SIMPLE-CONDITION
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SPECIALIZERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION READERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION WRITERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITERS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NKEYS)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NKEYS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION WRITERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION READERS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SPECIALIZERS)|
    PCL::DEFINITIONS PCL::DFUN-INFO-WRAPPER0 PCL::REMTAIL
    PCL::SPLIT-DECLARATIONS-MOVING-IGNORES PCL::MAKE-PV-TABLE
    COMMON-LISP::FLOOR PCL::GET-SYMBOL PCL::METHOD-CALL-P
    PCL::|__si::MAKE-INITIAL|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT 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 SLOT-OBJECT MAX-LOCATION)|
    PCL::|(FAST-WRITER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT MAX-LOCATION)| PCL::PARAMETERS
-   PCL::PARAMETER PCL::BUILT-IN
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITFUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ALLOCATION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DOCUMENTATION)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FUNCTION)| PCL::PARAMETER
+   PCL::PARAMETERS PCL::BUILT-IN
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS)|
    PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION CLASS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS)| PCL::FIRST-P
-   PCL::DFUN-INFO-ACCESSOR-TYPE CSTRUCT::C-FLOAT-DOUBLE->
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
+   PCL::FIRST-P PCL::DFUN-INFO-ACCESSOR-TYPE CSTRUCT::C-FLOAT-DOUBLE->
    PCL::SHORT-COMBINATION-OPERATOR COMMON-LISP::NSUBLIS
    PCL::GFS-OF-TYPE PCL::COPY-ACCESSOR-DFUN-INFO PCL::*MF1P*
    COMMON-LISP::YES-OR-NO-P CSTRUCT::C-SET-HASHTABLE-SELF
    PCL::METHOD-CLASS-NAME COMMON-LISP::INTERACTIVE-STREAM-P PCL::CAM
-   PCL::DEFSTRUCT-P PCL::ONE-INDEX-P PCL::ONE-ORDER-P
+   PCL::DEFSTRUCT-P PCL::ONE-ORDER-P PCL::ONE-INDEX-P
    PCL::INTERN-FUNCTION-NAME PCL::SLOTD PCL::INSTANCE-BOUNDP
    PCL::INSTANCE-WRITER CSTRUCT::C-FLOAT-FCOMPLEX-==
    CSTRUCT::C-FLOAT-DCOMPLEX-== PCL::KNOWN-TYPE
@@ -2225,46 +2226,46 @@
    PCL::|(SETF GF-DFUN-STATE)| PCL::FAST-INSTANCE-BOUNDP- PCL::SPEC
    PCL::R/W PCL::CONVERT-TABLE COMMON-LISP::CLOSE PCL::COLLECTING-ONCE
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
-   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::CONSTANTS PCL::TWO-CLASS
-   PCL::TWO-CLASS- PCL::CLASS-SLOTDS PCL::.FAST-CALL-METHOD.
+   PCL::ALLOCATE-FUNCALLABLE-INSTANCE PCL::CONSTANTS PCL::TWO-CLASS-
+   PCL::TWO-CLASS PCL::CLASS-SLOTDS PCL::.FAST-CALL-METHOD.
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LENGTH)|
    CSTRUCT::C-FLOAT-FLOAT-== PCL::STD-CLASS PCL::GET-CACHE-VECTOR
    CSTRUCT::C-SET-FUNCTION-ARGD
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NEXT-METHOD-CALL)| PCL::VAL
    PCL::CPD-CLASS PCL::READER-METHOD
    PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
-   PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::ARG PCL::ONE-CLASS
-   PCL::ONE-CLASS- COMMON-LISP::WITH-INPUT-FROM-STRING PCL::SMC-CLASS
+   PCL::EARLY-CLASS-DIRECT-SUBCLASSES PCL::ARG PCL::ONE-CLASS-
+   PCL::ONE-CLASS COMMON-LISP::WITH-INPUT-FROM-STRING PCL::SMC-CLASS
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT MASK)| PCL::OLD-CLASS
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SIZE)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT LINE-SIZE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SIZE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
    PCL::MAKE-EMF-FROM-METHOD PCL::%SET-CCLOSURE PCL::INITKEYS
    PCL::SDFUN-METHOD PCL::WRAPPERS-MISMATCH-P PCL::GCL_PCL_DLISP
-   PCL::METHOD-NAME PCL::METHOD-FN-NAME PCL::METACLASS PCL::NEW-CLASS
+   PCL::METHOD-FN-NAME PCL::METHOD-NAME PCL::NEW-CLASS PCL::METACLASS
    PCL::INDEX PCL::REQUIRED-ARGS+REST-ARG PCL::INSTANCE-READER
    PCL::PCL-CLASS PCL::BUILT-IN-CLASS-WRAPPER COMMON-LISP::EQL
    PCL::READER-NAME PCL::RESET-CLASS-INITIALIZE-INFO
-   PCL::ALLOCATE-STRUCTURE-INSTANCE PCL::ALLOCATE-STANDARD-INSTANCE
+   PCL::ALLOCATE-STANDARD-INSTANCE PCL::ALLOCATE-STRUCTURE-INSTANCE
    PCL::INITIAL COMMON-LISP::MASK-FIELD PCL::COMPILE-IIS-FUNCTIONS
    COMMON-LISP::COMPUTE-RESTARTS PCL::METHOD-LL->GENERIC-FUNCTION-LL
-   PCL::MAKE-FGEN PCL::|(BOUNDP SOURCE)| PCL::PV-WRAPPERS-FROM-PV-ARGS
-   PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::EARLY-CLASS-SLOTDS
+   PCL::MAKE-FGEN PCL::|(BOUNDP SOURCE)| PCL::PV-WRAPPERS-FROM-ALL-ARGS
+   PCL::PV-WRAPPERS-FROM-PV-ARGS PCL::EARLY-CLASS-SLOTDS
    PCL::VARIABLE-CLASS PCL::|(FAST-WRITER-METHOD SLOT-OBJECT FIELD)|
    PCL::|ARG-INFO SLOT10| PCL::CLASS-DECLARATIONS PCL::SOURCE
    PCL::GET-NEW-FUNCTION-GENERATOR COMMON-LISP::*DEBUG-IO* PCL::APPLYP
    PCL::CACHE-VECTOR-REF PCL::FUNCTION-P
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NAME)|
-   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DFUN-STATE)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION NAME)|
-   PCL::|(FAST-WRITER-METHOD CLASS NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAME)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)|
+   PCL::|(FAST-WRITER-METHOD CLASS NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NAME)|
+   PCL::|(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
    PCL::STD-INSTANCE-P SYSTEM::VOID PCL::SECTION PCL::CVECTOR
    PCL::MAKE-DUMMY-VAR PCL::UPDATE-GFS-OF-CLASS
    COMMON-LISP::RANDOM-STATE-P PCL::FINALIZEP PCL::|__si::MAKE-CACHING|
@@ -2318,21 +2319,21 @@
    PCL::SLOT-WRITER-SYMBOL PCL::FOR-ACCESSOR-P
    CSTRUCT::C-SET-PATHNAME-NAME CSTRUCT::C-SYMBOL-HPACK
    PCL::|(WRITER DEFSTRUCT-CONSTRUCTOR)| PCL::|PV-TABLE SLOT1|
-   PCL::GFS-TO-DO PCL::TRANSFORM PCL::TRANSFORMS PCL::NAME-DECL
+   PCL::GFS-TO-DO PCL::TRANSFORMS PCL::TRANSFORM PCL::NAME-DECL
    CSTRUCT::C-PATHNAME-HOST PCL::CLASS-INCOMPATIBLE-SUPERCLASS-LIST
    COMMON-LISP::PATHNAME-DEVICE PCL::GENERATOR-LAMBDA
    PCL::STANDARD-WRITER-METHOD-P PCL::PORT-DIRECTORY
    PCL::FREE-OLD-CACHE-P COMMON-LISP::SUBSEQ PCL::METATYPE
    CSTRUCT::C-ARRAY-HASFILLP CSTRUCT::C-SYMBOL-HASH
    PCL::CHECK-LAMBDA-LIST
-   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLASSES
-   PCL::CLAUSE PCL::*NAME->CLASS->SLOTD-TABLE*
+   PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO PCL::CLAUSE
+   PCL::CLASSES PCL::*NAME->CLASS->SLOTD-TABLE*
    PCL::EFFECTIVE-SLOT-DEFINITION-SIMPLE-TYPEP-FN PCL::INITARGS
-   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::COPY-FAST-METHOD-CALL PCL::|TYPE-PREDICATE PCL SPECIALIZER|
    PCL::|TYPE-PREDICATE PCL EXACT-CLASS-SPECIALIZER|
-   PCL::|TYPE-PREDICATE PCL SPECIALIZER| PCL::PLIST-P
+   PCL::|TYPE-PREDICATE PCL CLASS-EQ-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL CLASS-PROTOTYPE-SPECIALIZER|
+   PCL::|TYPE-PREDICATE PCL EQL-SPECIALIZER| PCL::PLIST-P
    COMMON-LISP::SET-EXCLUSIVE-OR COMMON-LISP::GENSYM
    PCL::|(WRITER ARG-INFO)| COMMON-LISP::REALPART
    CSTRUCT::C-SET-PATHNAME-DEVICE PCL::PLIST PCL::|(WRITER OPERATOR)|
@@ -2354,8 +2355,8 @@
    PCL::CLASS-SLOT-P PCL::DEFSTRUCT-ACCESSOR-SYMBOL PCL::READERS-INIT
    COMMON-LISP::*PRINT-PRETTY* PCL::|(SETF DOCUMENTATION)|
    PCL::NON-REQUIRED-ARGS PCL::EXISTING-P
-   PCL::FUNCALLABLE-INSTANCE-DATA PCL::EARLY-CLASS-SIZE PCL::FREE-CACHE
-   PCL::FROM-CACHE PCL::CHECK-QUALIFIERS COMMON-LISP::*QUERY-IO*
+   PCL::FUNCALLABLE-INSTANCE-DATA PCL::EARLY-CLASS-SIZE PCL::FROM-CACHE
+   PCL::FREE-CACHE PCL::CHECK-QUALIFIERS COMMON-LISP::*QUERY-IO*
    PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1 PCL::COPY-CACHE
    PCL::DECLARATION-SPECIFIERS COMMON-LISP::*PRINT-ARRAY*
    CSTRUCT::*SHORT PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
@@ -2368,23 +2369,22 @@
    PCL::FOR CSTRUCT::*FLOAT COMMON-LISP::POSITION
    COMMON-LISP::MAKE-SEQUENCE PCL::FIXUP PCL::METHOD-FUNCTION-METHOD
    PCL::CACHED-DEFAULT-INITARGS-FUNCTION
-   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
-   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
-   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
    PCL::|TYPE-PREDICATE PCL DEFINITION-SOURCE-MIXIN|
+   PCL::|TYPE-PREDICATE PCL PLIST-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DOCUMENTATION-MIXIN|
+   PCL::|TYPE-PREDICATE PCL DEPENDENT-UPDATE-MIXIN|
    PCL::GCL_PCL_ITERATE CSTRUCT::C-SYMBOL-NAME PCL::CANONICAL-SLOT
    PCL::|(WRITER CLASS-EQ-SPECIALIZER)| PCL::DEFCONSTRUCTOR
    PCL::%NO-PRIMARY-METHOD CSTRUCT::C-SET-PACKAGE-INTERNAL_FP
    CSTRUCT::C-SET-PACKAGE-EXTERNAL_FP
    PCL::CACHED-COMBINED-INITIALIZE-FUNCTION PCL::FORCE-CACHE-FLUSHES
-   PCL::INITIAL-
-   PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST
-   PCL::INITIALIZE-INFO-INITARGS-FORM-LIST
+   PCL::INITIAL- PCL::INITIALIZE-FORM-LIST
    PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
-   PCL::INITIALIZE-FORM-LIST PCL::|(READER INITARGS)|
-   COMMON-LISP::BOOLE-C2 PCL::RENEW-SYS-FILES
+   PCL::INITIALIZE-INFO-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-COMBINED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
+   PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
+   PCL::|(READER INITARGS)| COMMON-LISP::BOOLE-C2 PCL::RENEW-SYS-FILES
    COMMON-LISP::SET-DISPATCH-MACRO-CHARACTER
    COMMON-LISP::GET-DISPATCH-MACRO-CHARACTER SYSTEM::C-FCOMPLEX-==
    SYSTEM::C-DCOMPLEX-== COMMON-LISP::COMPLEMENT CSTRUCT::C-SPICE-DUMMY
@@ -2393,7 +2393,7 @@
    COMMON-LISP::RESTART-CASE PCL::PV-BINDING1 COMMON-LISP::PAIRLIS
    PCL::*ASV-BOUNDPS* PCL::EXTRA-P
    PCL::|(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)|
-   PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::INITIALIZE-INFO-CACHED-SLOTS
+   PCL::INITIALIZE-INFO-CACHED-SLOTS PCL::INITIALIZE-INFO-BOUND-SLOTS
    PCL::INITIALIZE-INITFNS COMMON-LISP::*PRINT-LINES* PCL::CPL
    PCL::LEGAL-SPECIALIZER-P PCL::INSTANCE-ACCESSOR-PARAMETER
    COMMON-LISP::STANDARD-CHAR-P PCL::CACHE-COUNT
@@ -2410,7 +2410,7 @@
    PCL::FIX-EARLY-GENERIC-FUNCTIONS PCL::*EQL-SPECIALIZER-TABLE*
    COMMON-LISP::*READ-DEFAULT-FLOAT-FORMAT*
    PCL::EARLY-COLLECT-DEFAULT-INITARGS PCL::GET-WRAPPERS-FROM-CLASSES
-   PCL::OMETHOD PCL::TMETHOD
+   PCL::TMETHOD PCL::OMETHOD
    PCL::|(INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
    PCL::DISPATCH-DFUN-INFO PCL::FALSE-CLAUSES PCL::EARLY-CLASS-NAME-OF
    CSTRUCT::C-SYMBOL-DBIND PCL::.PV-TABLE. PCL::TOP
@@ -2423,16 +2423,16 @@
    PCL::ELSE PCL::OSTATE COMMON-LISP::TWO-WAY-STREAM
    PCL::*SLOTD-BOUNDP-FUNCTION-STD-P* PCL::|(READER ARG-INFO)|
    COMMON-LISP::BIT-VECTOR-P COMMON-LISP::TYPE-ERROR-DATUM
-   PCL::|(CALL REAL-ADD-METHOD)| PCL::|(CALL REAL-REMOVE-METHOD)|
-   PCL::|(CALL REAL-GET-METHOD)| PCL::ONE-INDEX-DFUN-INFO-CACHE
+   PCL::|(CALL REAL-GET-METHOD)| PCL::|(CALL REAL-REMOVE-METHOD)|
+   PCL::|(CALL REAL-ADD-METHOD)| PCL::ONE-INDEX-DFUN-INFO-CACHE
    PCL::|(READER OPERATOR)| PCL::GET-INSTANCE-WRAPPER-OR-NIL
    CSTRUCT::C-T-PD1 SYSTEM::>> CSTRUCT::C-SET-PACKAGE-INTERNAL
    CSTRUCT::C-SET-PACKAGE-EXTERNAL PCL::DO-STANDARD-DEFSETF-1
    PCL::*CLASS-PV-TABLE-TABLE* PCL::ALLOW-OTHER-KEYS
    PCL::|SYSTEM:S-DATA SLOT5| PCL::DEFINE-DEFAULT-METHOD
    PCL::BOOTSTRAP-GET-SLOT PCL::INFO COMMON-LISP::*PRINT-MISER-WIDTH*
-   PCL::WRAPPERS+VALUE PCL::|(SETF CLASS-DIRECT-SLOTS)|
-   PCL::|(SETF CLASS-SLOTS)| PCL::COMPUTE-LINE-SIZE
+   PCL::WRAPPERS+VALUE PCL::|(SETF CLASS-SLOTS)|
+   PCL::|(SETF CLASS-DIRECT-SLOTS)| PCL::COMPUTE-LINE-SIZE
    PCL::WITHOUT-INTERRUPTS PCL::SCLASS PCL::MAKE-DISPATCH-DFUN
    WALKER::VARIABLE-DECLARATION PCL::FAST-SYM
    PCL::GET-WRAPPER-CACHE-NUMBER PCL::IF* PCL::INITIALIZE-INFO-WRAPPER
@@ -2440,26 +2440,26 @@
    COMMON-LISP::SPECIAL PCL::OCACHE PCL::NO-OF-INSTANCE-SLOTS
    PCL::INTERNAL-COUNT PCL::HOME-LOC PCL::|SYSTEM:S-DATA SLOT4|
    PCL::EARLY-FIND-CLASS-SYMBOL COMMON-LISP::DIGIT-CHAR-P
-   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
-   PCL::|COMMON-LISP::SYMBOL class predicate|
-   PCL::|COMMON-LISP::CHARACTER class predicate|
-   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
-   PCL::|COMMON-LISP::STRING class predicate|
-   PCL::|COMMON-LISP::VECTOR class predicate|
-   PCL::|COMMON-LISP::ARRAY class predicate|
-   PCL::|COMMON-LISP::STREAM class predicate|
-   PCL::|COMMON-LISP::FILE-STREAM class predicate|
-   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
-   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
-   PCL::|COMMON-LISP::STRING-STREAM class predicate|
-   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
-   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
-   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
-   PCL::|COMMON-LISP::HASH-TABLE class predicate|
-   PCL::|COMMON-LISP::PACKAGE class predicate|
-   PCL::|COMMON-LISP::READTABLE class predicate|
-   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
    PCL::|COMMON-LISP::PATHNAME class predicate|
+   PCL::|COMMON-LISP::LOGICAL-PATHNAME class predicate|
+   PCL::|COMMON-LISP::READTABLE class predicate|
+   PCL::|COMMON-LISP::PACKAGE class predicate|
+   PCL::|COMMON-LISP::HASH-TABLE class predicate|
+   PCL::|COMMON-LISP::SYNONYM-STREAM class predicate|
+   PCL::|COMMON-LISP::ECHO-STREAM class predicate|
+   PCL::|COMMON-LISP::TWO-WAY-STREAM class predicate|
+   PCL::|COMMON-LISP::STRING-STREAM class predicate|
+   PCL::|COMMON-LISP::CONCATENATED-STREAM class predicate|
+   PCL::|COMMON-LISP::BROADCAST-STREAM class predicate|
+   PCL::|COMMON-LISP::FILE-STREAM class predicate|
+   PCL::|COMMON-LISP::STREAM class predicate|
+   PCL::|COMMON-LISP::ARRAY class predicate|
+   PCL::|COMMON-LISP::VECTOR class predicate|
+   PCL::|COMMON-LISP::STRING class predicate|
+   PCL::|COMMON-LISP::BIT-VECTOR class predicate|
+   PCL::|COMMON-LISP::CHARACTER class predicate|
+   PCL::|COMMON-LISP::SYMBOL class predicate|
+   PCL::|COMMON-LISP::RANDOM-STATE class predicate|
    PCL::|COMMON-LISP::NULL class predicate|
    PCL::|COMMON-LISP::CONS class predicate|
    PCL::|COMMON-LISP::LIST class predicate|
@@ -2573,7 +2573,8 @@
    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
+   COMMON-LISP::ROTATEF CSTRUCT::C-SET-STRSTD-SSELF
+   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
@@ -2585,11 +2586,11 @@
    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
-   CSTRUCT::C-ARRAY-ADJUSTABLE PCL::MAP-CACHE PCL::FLAGS
-   PCL::SLOT-CLASS-WRAPPER PCL::PV-BINDING PCL::DISPATCH-P
-   PCL::DISPATCH- PCL::C-A-M-EMF PCL::NMS PCL::MT-TAIL
+   PCL::*DESTRUCTURE-VARS* PCL::INVALID CSTRUCT::C-SET-STRSTD-SDEF
+   PCL::GET-CACHE PCL::NEW-CACHE PCL::PV-CACHE-LIMIT-FN
+   PCL::INITIAL-CLASSES-AND-WRAPPERS CSTRUCT::C-ARRAY-ADJUSTABLE
+   PCL::MAP-CACHE PCL::FLAGS PCL::SLOT-CLASS-WRAPPER PCL::PV-BINDING
+   PCL::DISPATCH-P PCL::DISPATCH- PCL::C-A-M-EMF PCL::NMS PCL::MT-TAIL
    PCL::*DFUN-CONSTRUCTORS* PCL::*STRUCTURE-TYPEP-COST*
    PCL::CACHE-MISS-VALUES-INTERNAL PCL::CHECK-INITARGS-VALUES
    PCL::.CALL-METHOD. PCL::OVERFLOW PCL::N-N-CACHE
@@ -2692,13 +2693,14 @@
    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
-   CSTRUCT::C-FUNCTION-SELF PCL::CLASS1-SUB PCL::OSLOTS PCL::WRAPPER
-   PCL::DEFINITION-BEFORE-PCL CSTRUCT::C-FIXNUM-FIXNUM->
-   PCL::FUNCTION-RETURNING-NIL PCL::TYPE+COUNT+SIZES
-   COMMON-LISP::ARRAY-RANK-LIMIT PCL::GFSPEC CSTRUCT::C-STRUCTURE-SELF
-   PCL::ERROR-P PCL::*NON-BUILT-IN-TYPEP-COST*
-   PCL::|INITIALIZE-INFO SLOT5| PCL::STRUCTURE-SLOTD-TYPE
-   PCL::*OPTIMIZE-ASV-FUNCALL-P* CSTRUCT::C-CFDATA-SELF PCL::QUALIFIERS
+   CSTRUCT::C-FUNCTION-SELF CSTRUCT::C-STRSTD-SSELF PCL::CLASS1-SUB
+   PCL::OSLOTS PCL::WRAPPER PCL::DEFINITION-BEFORE-PCL
+   CSTRUCT::C-FIXNUM-FIXNUM-> PCL::FUNCTION-RETURNING-NIL
+   PCL::TYPE+COUNT+SIZES COMMON-LISP::ARRAY-RANK-LIMIT PCL::GFSPEC
+   CSTRUCT::C-STRUCTURE-SELF PCL::ERROR-P
+   PCL::*NON-BUILT-IN-TYPEP-COST* PCL::|INITIALIZE-INFO SLOT5|
+   PCL::STRUCTURE-SLOTD-TYPE PCL::*OPTIMIZE-ASV-FUNCALL-P*
+   CSTRUCT::C-CFDATA-SELF PCL::QUALIFIERS
    PCL::DEFAULT-METHOD-ONLY-CACHE PCL::|(READER SLOTS)|
    CSTRUCT::C-FIXNUM-FLOAT-> PCL::SPECIFIER
    COMMON-LISP::POSITION-IF-NOT PCL::VALID-KEYS
@@ -2708,8 +2710,9 @@
    PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|
    PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))| PCL::WITH
    CSTRUCT::C-T-MELTTYPE PCL::|INITIALIZE-INFO SLOT4|
-   PCL::|(READER PLIST)| PCL::WRAPPER-CLASS* PCL::STRUCTURE-SVUC-METHOD
-   PCL::COUNT-DFUN PCL::GET-SECONDARY-DISPATCH-FUNCTION2
+   PCL::|(READER PLIST)| CSTRUCT::C-STRSTD-SDEF 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
@@ -2720,10 +2723,60 @@
    PCL::|INITIALIZE-INFO SLOT3| PCL::XEROX-PATCHES
    PCL::LIST-LARGE-CACHES PCL::INVALID-WRAPPER-P
    CSTRUCT::C-SET-STRUCTURE-SELF
+   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))| 
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
+   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
+   PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
+   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
+   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))| 
+   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
+   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
    PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
    PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
    PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|
-   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
+   PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))| 
    PCL::|(FAST-METHOD INVALID-QUALIFIERS (GENERIC-FUNCTION T T T))|
    PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
    PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
@@ -2754,59 +2807,9 @@
    PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
    PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
    PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))| 
+   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD :AROUND (GENERIC-FUNCTION METHOD-COMBINATION T))|
    PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
    PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
-   PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
-   PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
-   PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
-   PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T T))|
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
-   PCL::|(FAST-METHOD FIND-METHOD (STANDARD-GENERIC-FUNCTION T T))|
-   PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))| 
-   PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (T T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
-   PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
-   PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-   PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-   PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
-   PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN T))|
-   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-   PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-   PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-   PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
-   PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
-   PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
    PCL::GET-SECONDARY-DISPATCH-FUNCTION1 PCL::EARLY-MAKE-A-METHOD
    PCL::IOA COMMON-LISP::VECTOR-POP PCL::OPERATE-ON-SYSTEM
    PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::INITARGS-FORM
@@ -2823,8 +2826,8 @@
    CSTRUCT::C-SET-CFDATA-SELF PCL::AKEY COMMON-LISP::LENGTH
    PCL::MAKE-DFUN-LAMBDA-LIST PCL::NEW-TYPE PCL::CMU-LOW PCL::OK
    CSTRUCT::C-SET-ARRAY-SELF PCL::PV-TABLES PCL::GCL_PCL_FAST_INIT
-   PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::KLIST-TAIL
-   PCL::ALIST-TAIL PCL::*DEFCLASS-TIMES*
+   PCL::MAKE-INSTANCE-FUNCTION-KEYS COMMON-LISP::CHAR>= PCL::ALIST-TAIL
+   PCL::KLIST-TAIL PCL::*DEFCLASS-TIMES*
    PCL::*SHOW-MAKE-UNORDERED-METHODS-EMF-CALLS*
    COMMON-LISP::DO-EXTERNAL-SYMBOLS PCL::|INITIALIZE-INFO SLOT0|
    PCL::SLOTS-INIT COMMON-LISP::CHAR<= SYSTEM::C+
@@ -2841,8 +2844,8 @@
    PCL::LOCATION-RESERVED-P COMMON-LISP::++
    PCL::STRUCTURE-DIRECT-SLOT-DEFINITION COMMON-LISP::*GENSYM-COUNTER*
    PCL::COPY-STRUCTURE-OBJECT PCL::|(READER NAME)| PCL::.SPECIALIZERS.
-   PCL::*INLINE-IIS-INSTANCE-LOCATIONS-P* PCL::GET-CLASS-SLOT-VALUE-1
-   PCL::SET-CLASS-SLOT-VALUE-1 PCL::ENVIRONMENT
+   PCL::*INLINE-IIS-INSTANCE-LOCATIONS-P* PCL::SET-CLASS-SLOT-VALUE-1
+   PCL::GET-CLASS-SLOT-VALUE-1 PCL::ENVIRONMENT
    PCL::STRUCTURE-CLASS-WRAPPER PCL::ALL-APPLICABLE PCL::*FIND-CLASS*
    PCL::MAYBE-OPTIMIZE-READER COMMON-LISP::BYTE-SIZE PCL::PYR-LOW
    PCL::DESCRIBE-PACKAGE PCL::CM-ARGS CSTRUCT::C-SET-T-EMF
@@ -2887,38 +2890,38 @@
    PCL::FAST-INSTANCE-BOUNDP PCL::GENERIC-FUNCTION-NAME-P CSTRUCT::*INT
    PCL::LOCATION-VALUE PCL::COPY-N-N COMMON-LISP::DEFPACKAGE
    PCL::APPLICABLE PCL::ACCESSOR-MISS
-   COMMON-LISP::WITH-OUTPUT-TO-STRING PCL::CLASS-KEY PCL::SLOTS-KEY
+   COMMON-LISP::WITH-OUTPUT-TO-STRING PCL::SLOTS-KEY PCL::CLASS-KEY
    PCL::SLOT-VARS PCL::*PATHNAME-EXTENSIONS* COMMON-LISP::SHIFTF
    COMMON-LISP::RETURN PCL::.CALL. PCL::COPY-CONSTANT-VALUE
-   PCL::LONG-METHOD-COMBINATION-FUNCTION PCL::LONG-METHOD-COMBINATION
+   PCL::LONG-METHOD-COMBINATION PCL::LONG-METHOD-COMBINATION-FUNCTION
    PCL::*THE-WRAPPER-OF-FLOAT* PCL::|(BOUNDP INITARGS)| PCL::FOUND-P
    COMMON-LISP::SIGNUM PCL::*ACCESSORS* CSTRUCT::C-SET-STRUCTURE-DEF
    PCL::CHECK-METH PCL::*THE-WRAPPER-OF-CONS* PCL::ACCESSOR-SLOT-VALUE
    PCL::ASV-FUNCALL SYSTEM::TP7 COMMON-LISP::FIXNUM
    PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P PCL::MEC-ALL-CLASSES-INTERNAL
-   PCL::PV-TABLE-P PCL::PV-TABLE- COMMON-LISP::BIT-NOR
+   PCL::PV-TABLE- PCL::PV-TABLE-P COMMON-LISP::BIT-NOR
    PCL::FIND-STRUCTURE-CLASS PCL::%SET-SVREF PCL::*THE-WRAPPER-OF-NULL*
    PCL::PRECOMPILE-DFUN-CONSTRUCTOR PCL::*THE-CLASS-ARRAY*
    PCL::|(FAST-INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
    PCL::INIT-TYPE
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| PCL::SO-P
-   PCL::NEW-SUPPLIED-P PCL::*CASE-TABLE-LIMIT* PCL::RESULT
-   PCL::*THE-WRAPPER-OF-LIST* PCL::*THE-CLASS-EQL-SPECIALIZER*
-   PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
-   PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
+   PCL::SO-P PCL::NEW-SUPPLIED-P PCL::*CASE-TABLE-LIMIT* PCL::RESULT
+   PCL::*THE-WRAPPER-OF-LIST* PCL::*THE-CLASS-SPECIALIZER*
    PCL::*THE-CLASS-EXACT-CLASS-SPECIALIZER*
-   PCL::*THE-CLASS-SPECIALIZER* CSTRUCT::LISP-TYPE PCL::DFUN-TYPE
+   PCL::*THE-CLASS-CLASS-EQ-SPECIALIZER*
+   PCL::*THE-CLASS-CLASS-PROTOTYPE-SPECIALIZER*
+   PCL::*THE-CLASS-EQL-SPECIALIZER* CSTRUCT::LISP-TYPE PCL::DFUN-TYPE
    PCL::IMPROPER-LIST-HANDLER PCL::*SLOT-ACCESSOR-NAME-PACKAGE*
    PCL::|CACHE SLOT11| CSTRUCT::C-HASHTABLE-RHSIZE
    CSTRUCT::C-HASHTABLE-SIZE
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DECLARATIONS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITIAL-METHODS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITIAL-METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DECLARATIONS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
    PCL::COPY-ONE-INDEX-DFUN-INFO PCL::|(BOUNDP INITIALIZE-INFO)|
    PCL::ALL PCL::*THE-WRAPPER-OF-STRUCTURE-OBJECT* PCL::CACHING
@@ -2927,59 +2930,59 @@
    PCL::|(SETF SLOT-DEFINITION-INITFORM)| PCL::FIELD PCL::UNKNOWN
    PCL::MAKE-TWO-CLASS PCL::|(SETF SLOT-DEFINITION-TYPE)|
    PCL::*THE-CLASS-COMPLEX* PCL::READER/WRITER PCL::ALIST-ENTRY
-   PCL::*THE-CLASS-BIT-VECTOR* PCL::*THE-CLASS-CHARACTER*
-   PCL::*THE-CLASS-VECTOR* PCL::ORIGINAL SYSTEM::TP6
+   PCL::*THE-CLASS-VECTOR* PCL::*THE-CLASS-CHARACTER*
+   PCL::*THE-CLASS-BIT-VECTOR* PCL::ORIGINAL SYSTEM::TP6
    PCL::|CACHE SLOT10| PCL::|__si::MAKE-N-N|
-   PCL::|(SETF SLOT-DEFINITION-READERS)|
    PCL::|(SETF SLOT-DEFINITION-WRITERS)|
-   PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
-   PCL::*THE-CLASS-DOCUMENTATION-MIXIN* PCL::*THE-CLASS-PLIST-MIXIN*
+   PCL::|(SETF SLOT-DEFINITION-READERS)|
    PCL::*THE-CLASS-DEFINITION-SOURCE-MIXIN*
+   PCL::*THE-CLASS-PLIST-MIXIN* PCL::*THE-CLASS-DOCUMENTATION-MIXIN*
+   PCL::*THE-CLASS-DEPENDENT-UPDATE-MIXIN*
    PCL::MAKE-INSTANCE-FUNCTION-SYMBOL PCL::REBOUND?
    PCL::*THE-WRAPPER-OF-FUNCTION* PCL::WRAPPER1
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LAMBDA-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PLIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
    COMMON-LISP::STRING-LESSP PCL::SLOT-INITARGS PCL::THING PCL::LMF
    PCL::EMIT-CONSTANT-VALUE PCL::KCL-LOW
    PCL::LONG-METHOD-COMBINATION-SIMPLE-TYPEP-FN
    PCL::|(BOUNDP DEFSTRUCT-CONSTRUCTOR)| PCL::FMF
    COMMON-LISP::CHAR-NOT-EQUAL PCL::MAKE-CLASS-PREDICATE-NAME
    PCL::COMPUTE-STD-CPL-PHASE-2 PCL::ADD-DIRECT-SUBCLASSES PCL::EMF
-   PCL::|(SETF SLOT-DEFINITION-LOCATION)|
-   PCL::|(SETF SLOT-DEFINITION-READER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-WRITER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-BOUNDP-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-INTERNAL-READER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION)|
-   PCL::|(SETF SLOT-DEFINITION-ALLOCATION)|
+   PCL::|(SETF SLOT-ACCESSOR-FUNCTION)|
    PCL::|(SETF SLOT-DEFINITION-INITFUNCTION)|
-   PCL::|(SETF SLOT-ACCESSOR-FUNCTION)| PCL::CONSTRUCTORS
+   PCL::|(SETF SLOT-DEFINITION-ALLOCATION)|
+   PCL::|(SETF SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-INTERNAL-READER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-BOUNDP-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-WRITER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-READER-FUNCTION)|
+   PCL::|(SETF SLOT-DEFINITION-LOCATION)| PCL::CONSTRUCTORS
    PCL::*THE-CLASS-RATIO* PCL::MAKE-CHECKING-DFUN PCL::CLASS-NAMES
-   PCL::|(SETF SLOT-DEFINITION-CLASS)|
    PCL::|(SETF SLOT-VALUE-USING-CLASS)|
+   PCL::|(SETF SLOT-DEFINITION-CLASS)|
    PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
    PCL::*ENABLE-DFUN-CONSTRUCTOR-CACHING*
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT OBJECT)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)| PCL::AFTER
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)| PCL::AFTER
    PCL::RESET-PACKAGE PCL::CHECKING-MISS PCL::LINE
-   PCL::*THE-WRAPPER-OF-STREAM* PCL::*THE-WRAPPER-OF-FILE-STREAM*
-   PCL::*THE-WRAPPER-OF-BROADCAST-STREAM*
-   PCL::*THE-WRAPPER-OF-CONCATENATED-STREAM*
-   PCL::*THE-WRAPPER-OF-STRING-STREAM*
-   PCL::*THE-WRAPPER-OF-TWO-WAY-STREAM*
+   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM*
    PCL::*THE-WRAPPER-OF-ECHO-STREAM*
-   PCL::*THE-WRAPPER-OF-SYNONYM-STREAM* PCL::CPL-ERROR
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::*THE-WRAPPER-OF-TWO-WAY-STREAM*
+   PCL::*THE-WRAPPER-OF-STRING-STREAM*
+   PCL::*THE-WRAPPER-OF-CONCATENATED-STREAM*
+   PCL::*THE-WRAPPER-OF-BROADCAST-STREAM*
+   PCL::*THE-WRAPPER-OF-FILE-STREAM* PCL::*THE-WRAPPER-OF-STREAM*
+   PCL::CPL-ERROR PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
    PCL::*PREVIOUS-NWRAPPERS* CSTRUCT::C-DOUBLE-FLOAT-==
    PCL::|(BOUNDP ARG-INFO)| ITERATE::WHILE PCL::*THE-WRAPPER-OF-REAL*
    PCL::KIND PCL::EMIT-ONE-CLASS-WRITER COMMON-LISP::COMPILED-FUNCTION
@@ -2987,39 +2990,40 @@
    PCL::COMPUTE-STD-CPL-PHASE-1 PCL::UNPARSED-SPECIALIZERS
    COMMON-LISP::LISP-IMPLEMENTATION-VERSION PCL::OWNER
    PCL::MAKE-MODULES PCL::CACHING-P CSTRUCT::C-HASHTABLE-SELF
-   COMMON-LISP::FIND PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-COMBINATION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-DEFINITION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FAST-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LOCATION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ALLOCATION)|
+   COMMON-LISP::FIND
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ALLOCATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT READER-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
    PCL::*SECONDARY-DFUN-CALL-COST* PCL::MAKE-DFUN-ARG-LIST
    PCL::*REVERT-INITIALIZE-INFO-P* CSTRUCT::C-SET-STREAM-FD
    CSTRUCT::C-PACKAGE-SHADOWINGS PCL::*THE-WRAPPER-OF-STRING*
-   SYSTEM::TP5 PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
+   SYSTEM::TP5 PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)| PCL::*BOOT-STATE*
-   PCL::*SGF-DFUN-STATE-INDEX* PCL::CACHE-OWNER PCL::RESET-PCL-PACKAGE
-   PCL::NEW-KEYS PCL::POSSIBLY-APPLICABLE COMMON-LISP::EXPT
-   PCL::LIST-LARGE-CACHE PCL::.METHOD-COMBINATION.
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::*BOOT-STATE* PCL::*SGF-DFUN-STATE-INDEX* PCL::CACHE-OWNER
+   PCL::RESET-PCL-PACKAGE PCL::NEW-KEYS PCL::POSSIBLY-APPLICABLE
+   COMMON-LISP::EXPT PCL::LIST-LARGE-CACHE PCL::.METHOD-COMBINATION.
    PCL::FORMAT-ARGUMENTS SYSTEM::C* PCL::*THE-CLASS-RATIONAL*
    CSTRUCT::C-SET-READTABLE-SELF PCL::META-SPECIALIZER
    PCL::LOAD-DEFCLASS PCL::TRUE-VALUE COMMON-LISP::FILL
    PCL::CACHED-SLOT-NAMES PCL::ACCESSOR-NAMES COMMON-LISP::TIME
    PCL::THREAD
-   PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
-   PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
-   PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
-   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :DEFINITION-SOURCE :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
    PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :FUNCTION :FUNCTION :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :DEFINITION-SOURCE :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :DEFINITION-SOURCE :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-READER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-BOUNDP-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
+   PCL::|MAKE-INSTANCE STANDARD-WRITER-METHOD (:QUALIFIERS :LAMBDA-LIST :SPECIALIZERS :DOCUMENTATION :SLOT-NAME :ALLOW-OTHER-KEYS :METHOD-SPEC :FAST-FUNCTION :PLIST :PLIST :FAST-FUNCTION :METHOD-SPEC :ALLOW-OTHER-KEYS :SLOT-NAME :DOCUMENTATION :SPECIALIZERS :LAMBDA-LIST :QUALIFIERS) T|
    COMMON-LISP::COMPILER-MACRO-FUNCTION CSTRUCT::C-DOUBLE-DOUBLE->
    PCL::METHOD-SYM PCL::NEW-NAME PCL::EMIT-ONE-CLASS-READER
    PCL::ORIG-METHODS COMMON-LISP::PRINT-UNREADABLE-OBJECT PCL::VALUEP
@@ -3029,19 +3033,19 @@
    PCL::CLASS-EQ-TEST PCL::*EMF-CALL-TRACE-SIZE*
    PCL::COMBINED-INITARGS-FORM-LIST PCL::ADD-WRITER-METHOD
    PCL::CONSTANT-VALUE-CACHE PCL::IMPROPER-LIST PCL::WRITER-NAMES
-   PCL::NO-METHODS PCL::DO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
+   PCL::DO-METHODS PCL::NO-METHODS WALKER::WALK-FORM-EXPAND-MACROS-P
    CSTRUCT::C-READTABLE-CASE PCL::METAOBJECT-SIMPLE-TYPEP-FN
    PCL::DIRECT-SUPERCLASSES COMMON-LISP::READ-CHAR-NO-HANG
    PCL::*METHOD-FUNCTION-PLIST* PCL::FIELD-NUMBER
-   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::*THE-WRAPPER-OF-RANDOM-STATE*
-   PCL::*THE-WRAPPER-OF-PACKAGE* PCL::*THE-WRAPPER-OF-LOGICAL-PATHNAME*
-   PCL::*THE-WRAPPER-OF-PATHNAME* SYSTEM::TP4 COMMON-LISP::MACROEXPAND
-   PCL::MAKE-SHARED-INITIALIZE-FORM-LIST PCL::INITIALIZATION-ARGUMENTS
-   COMMON-LISP::SHORT-FLOAT PCL::*THE-CLASS-SEQUENCE*
-   COMMON-LISP::NOTINLINE COMMON-LISP::IDENTITY
-   PCL::|(SETF SLOT-DEFINITION-NAME)| PCL::GF-KEY/REST-P
-   PCL::|(BOUNDP CLASS-EQ-SPECIALIZER)| PCL::CURRENT-CLASS
-   PCL::NEW-NLINES PCL::*THE-CLASS-SYMBOL*
+   PCL::MAYBE-EXPAND-ACCESSOR-FORM PCL::*THE-WRAPPER-OF-PATHNAME*
+   PCL::*THE-WRAPPER-OF-LOGICAL-PATHNAME* PCL::*THE-WRAPPER-OF-PACKAGE*
+   PCL::*THE-WRAPPER-OF-RANDOM-STATE* SYSTEM::TP4
+   COMMON-LISP::MACROEXPAND PCL::MAKE-SHARED-INITIALIZE-FORM-LIST
+   PCL::INITIALIZATION-ARGUMENTS COMMON-LISP::SHORT-FLOAT
+   PCL::*THE-CLASS-SEQUENCE* COMMON-LISP::NOTINLINE
+   COMMON-LISP::IDENTITY PCL::|(SETF SLOT-DEFINITION-NAME)|
+   PCL::GF-KEY/REST-P PCL::|(BOUNDP CLASS-EQ-SPECIALIZER)|
+   PCL::CURRENT-CLASS PCL::NEW-NLINES PCL::*THE-CLASS-SYMBOL*
    CSTRUCT::C-SET-READTABLE-CASE PCL::.CACHE.
    PCL::ACCESSOR-SET-SLOT-VALUE
    PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
@@ -3051,42 +3055,41 @@
    COMMON-LISP::BIT-ORC1 PCL::FILE
    PCL::|(BOUNDP DEFSTRUCT-ACCESSOR-SYMBOL)| PCL::NEXT-METHOD-P-BODY
    CSTRUCT::C-FLOAT-FLOAT->
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)|
    PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-NAME)|
-   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)| PCL::MIF-KEY
-   COMMON-LISP::IMAGPART PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD*
-   PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)| PCL::MIF-KEY
+   COMMON-LISP::IMAGPART PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD*
+   PCL::*THE-CLASS-METHOD* PCL::*THE-CLASS-STANDARD-METHOD*
    PCL::*THE-CLASS-STANDARD-READER-METHOD*
-   PCL::*THE-CLASS-STANDARD-METHOD* PCL::*THE-CLASS-METHOD*
-   PCL::*THE-CLASS-STANDARD-ACCESSOR-METHOD* COMMON-LISP::CHAR-DOWNCASE
+   PCL::*THE-CLASS-STANDARD-WRITER-METHOD*
+   PCL::*THE-CLASS-STANDARD-BOUNDP-METHOD* COMMON-LISP::CHAR-DOWNCASE
    CSTRUCT::C-STRUCTURE-DEF
    PCL::EXACT-CLASS-SPECIALIZER-SIMPLE-TYPEP-FN PCL::DIRECT-SUBCLASSES
    PCL::CHECK-FUNCTION CSTRUCT::C-SET-RATIO-NUM PCL::SORTED-CALLS
    PCL::*FREE-CACHE-VECTORS* PCL::WRITER-SYMBOL PCL::SLOTS-TO-INSPECT
-   PCL::FMC-FUNCALL PCL::EMF-FUNCALL SYSTEM::TP3 PCL::SMC
-   PCL::PV-TABLE-SLOT-NAME-LISTS
-   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN
+   PCL::EMF-FUNCALL PCL::FMC-FUNCALL SYSTEM::TP3 PCL::SMC
+   PCL::PV-TABLE-SLOT-NAME-LISTS PCL::MAKE-FINAL-ACCESSOR-DFUN
+   PCL::MAKE-FINAL-CHECKING-DFUN PCL::MAKE-FINAL-DISPATCH-DFUN
+   PCL::MAKE-FINAL-CACHING-DFUN PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN
    PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN
-   PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN PCL::MAKE-FINAL-CACHING-DFUN
-   PCL::MAKE-FINAL-DISPATCH-DFUN PCL::MAKE-FINAL-CHECKING-DFUN
-   PCL::MAKE-FINAL-ACCESSOR-DFUN PCL::MODULE-COMP-ENV
-   PCL::MODULE-LOAD-ENV PCL::LOAD-DEFMETHOD-INTERNAL PCL::SETQS
+   PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN PCL::MODULE-LOAD-ENV
+   PCL::MODULE-COMP-ENV PCL::LOAD-DEFMETHOD-INTERNAL PCL::SETQS
    PCL::NMC PCL::EMIT-MISS PCL::|(BOUNDP WRAPPER)|
    CSTRUCT::C-SET-FUNCTION-VV PCL::*LAZY-DFUN-COMPUTE-P*
-   PCL::SORT-METHODS PCL::*THE-CLASS-READTABLE*
-   PCL::*THE-CLASS-HASH-TABLE* COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS
+   PCL::SORT-METHODS PCL::*THE-CLASS-HASH-TABLE*
+   PCL::*THE-CLASS-READTABLE* COMMON-LISP::STRING-EQUAL PCL::DFUN-MISS
    PCL::COMPILE-FILTER PCL::NEW-ICUI CSTRUCT::C-T-MDIM
    PCL::PV-TABLE-PV-SIZE PCL::ALLOCATE COMMON-LISP::SYMBOL-PACKAGE
    PCL::MAKE-PROGN PCL::CONSTANT-VALUE PCL::TO-CACHE PCL::LMF-PARAMS
    PCL::*EQ-CASE-TABLE-LIMIT* PCL::COPY-INITIALIZE-INFO PCL::TESTS
    PCL::REAL-METHOD-COMBINATION-ERROR CSTRUCT::C-HASHTABLE-CACHE
-   PCL::GET-VAL PCL::SET-VAL CSTRUCT::C-PATHNAME-DEVICE
+   PCL::SET-VAL PCL::GET-VAL CSTRUCT::C-PATHNAME-DEVICE
    COMMON-LISP::SVREF PCL::ACCESSOR-DFUN-INFO-CACHE PCL::FIX
    PCL::CLASS-CONSTRUCTORS PCL::PVREF PCL::INVOKE-FAST-METHOD-CALL
    PCL::{METHOD-QUALIFIER}* PCL::FORMAT-ARGS
    PCL::FINISH-PUSHING-INITARGS PCL::FORMAT-CYCLE-REASONS
-   PCL::STD-MI-METH PCL::STD-SI-METH PCL::STD-II-METH
+   PCL::STD-II-METH PCL::STD-SI-METH PCL::STD-MI-METH
    PCL::METHOD-GROUP-SPECIFIERS PCL::PROPERTY-LIST
    PCL::PV-TABLE-LOOKUP-PV-ARGS PCL::RESTP PCL::K+M
    PCL::MAKE-INSTANCE-FUNCTION-SIMPLE SYSTEM::TP2 PCL::GBOUNDP
@@ -3129,17 +3132,17 @@
    PCL::PRECOMPILE-INITIALIZE-INSTANCE-SIMPLE PCL::*EMPTY-PV*
    PCL::SYSTEM-BINARY-FILES
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::FUN-VALUES)|
-   PCL::MAKE-FINAL-DFUN-INTERNAL PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL
+   PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL PCL::MAKE-FINAL-DFUN-INTERNAL
    PCL::CALL-METHOD-LIST PCL::CLASS-METHOD-INITARGS
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::OFFSET)|
    PCL::WRAPPER-CACHE-NUMBER-VECTOR-REF PCL::CLASS-NAME-OF
    CSTRUCT::C-SET-T-ST PCL::METHOD2 PCL::*ALL-PV-TABLE-LIST*
    PCL::FSC-INSTANCE-SLOTS PCL::SORTER PCL::NEW-DEFINITION
    CSTRUCT::C-STREAM-INT CSTRUCT::C-STREAM-FP PCL::OTYPE PCL::SUBFORM
-   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
    PCL::|(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)| PCL::NTYPE
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
+   PCL::|(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)| PCL::NTYPE
    PCL::POS-FORM COMMON-LISP::MAPLIST COMMON-LISP::FILE-AUTHOR
    PCL::FSC-INSTANCE-CLASS PCL::EMIT-READER/WRITER-FUNCTION PCL::OUTER
    PCL::PV-TABLE-SYMBOL PCL::PV-INDEX
@@ -3152,22 +3155,22 @@
    PCL::REQUIRED
    PCL::|(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
    PCL::*UMI-COMPLETE-CLASSES*
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION OPTIONS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT OPTIONS)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHODS)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DECLARATIONS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DECLARATIONS)|
-   PCL::|(FAST-READER-METHOD GENERIC-FUNCTION INITIAL-METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITIAL-METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-CLASS DIRECT-SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-CLASS SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOTS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-METHODS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT RECOMP-REASONS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-DESCRIPTIONS)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONSTRUCTORS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-DESCRIPTIONS)| 
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT RECOMP-REASONS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-CLASS SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-CLASS DIRECT-SLOTS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITIAL-METHODS)|
+   PCL::|(FAST-READER-METHOD GENERIC-FUNCTION INITIAL-METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DECLARATIONS)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DECLARATIONS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHODS)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OPTIONS)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION OPTIONS)|
    PCL::UNCOMPILED COMMON-LISP::STRING-UPCASE
    COMMON-LISP::STRING-DOWNCASE CSTRUCT::C-T-MHASFILLP
    PCL::GF-DFUN-INFO PCL::POP-INTO
@@ -3181,127 +3184,129 @@
    COMMON-LISP::MAP-INTO PCL::EARLY-GF-METHODS
    PCL::MAKE-STRUCTURE-OBJECT PCL::LIST-PV
    COMMON-LISP::ARITHMETIC-ERROR PCL::GET-FUNCTION-GENERATOR
-   PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION ARGUMENTS-LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LAMBDA-LIST)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS CAN-PRECEDE-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
-   PCL::|(FAST-READER-METHOD PLIST-MIXIN PLIST)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT PLIST)|
+   PCL::|(FAST-READER-METHOD PLIST-MIXIN PLIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS CAN-PRECEDE-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS CLASS-PRECEDENCE-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ARGUMENTS-LAMBDA-LIST)|
+   PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION ARGUMENTS-LAMBDA-LIST)|
    CSTRUCT::C-SET-STREAM-OBJECT1 PCL::FORWARD-CLASS PCL::SAUT-NOT-EQL
    COMMON-LISP::PROVIDE PCL::SLOT-REGS
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)| PCL::BY
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMP-ENV)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOAD-ENV)| PCL::BY
    CSTRUCT::C-ARRAY-RANK PCL::DI PCL::*DEFMETHOD-TIMES* PCL::IIS-BODY
    PCL::DEFINE-INITIALIZE-INFO CSTRUCT::C-SET-CHARACTER-CODE
    COMMON-LISP::PPRINT-EXIT-IF-LIST-EXHAUSTED PCL::TYPE-SPEC
    PCL::PV-OFFSET-LIST PCL::BEFORE
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFORM)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFORM)|
-   PCL::|(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFORM)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFORM)|
    PCL::WITH-EQ-HASH-TABLE
-   PCL::|(FAST-READER-METHOD EQL-SPECIALIZER OBJECT)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT OBJECT)|
-   PCL::|(FAST-READER-METHOD CLASS-PROTOTYPE-SPECIALIZER OBJECT)|
-   PCL::|(FAST-READER-METHOD CLASS-EQ-SPECIALIZER OBJECT)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
    PCL::|(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT TYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION TYPE)|
-   PCL::|(FAST-READER-METHOD PCL-CLASS PROTOTYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PROTOTYPE)|
-   PCL::|(FAST-READER-METHOD SPECIALIZER TYPE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
+   PCL::|(FAST-READER-METHOD CLASS-EQ-SPECIALIZER OBJECT)|
+   PCL::|(FAST-READER-METHOD CLASS-PROTOTYPE-SPECIALIZER OBJECT)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT OBJECT)|
+   PCL::|(FAST-READER-METHOD EQL-SPECIALIZER OBJECT)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::RETURN-TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::VALUE-TYPE)|
+   PCL::|(FAST-READER-METHOD SPECIALIZER TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PROTOTYPE)|
+   PCL::|(FAST-READER-METHOD PCL-CLASS PROTOTYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION TYPE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT TYPE)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)|
    PCL::*SUBTYPEP PCL::EMF-TYPE CSTRUCT::C-SET-T-E
    CSTRUCT::C-SET-HASHTABLE-TEST CSTRUCT::C-T-MWRITABLE PCL::CONVERTED
    PCL::STD-INSTANCE-WRAPPER
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION READERS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT READERS)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION WRITERS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITERS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT NKEYS)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::CALLEES)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT NKEYS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITERS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION WRITERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT READERS)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION READERS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM:STATICP)|
    CSTRUCT::C-SET-STREAM-OBJECT0
    PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION CSTRUCT::C-FUNCTION-NEVAL
    PCL::EQL-SPECIALIZER-SIMPLE-TYPEP-FN PCL::ONE-INDEX-INDEX
    PCL::|__si::MAKE-DEFAULT-METHOD-ONLY| PCL::SLOTS-TO-REVERT
    PCL::NUMBER-REQUIRED
-   PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DOCUMENTATION)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
-   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-DEFINITION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STANDARD-METHOD FAST-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT FAST-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOCATION)|
-   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
-   PCL::|(FAST-READER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ALLOCATION)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
-   PCL::|(FAST-READER-METHOD TRACED-METHOD FUNCTION)|
-   PCL::|(FAST-READER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT MAX-LOCATION)|
+   PCL::|(FAST-READER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD TRACED-METHOD FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SLOT-POSITION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::PRINT-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INITFUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION INITFUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ALLOCATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT READER-FUNCTION)| 
+   PCL::|(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT LOCATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FAST-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD FAST-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
+   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-DEFINITION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DOCUMENTATION)|
+   PCL::|(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
+   PCL::|(FAST-READER-METHOD LONG-METHOD-COMBINATION FUNCTION)|
    PCL::DIRECT-SLOTDS PCL::MAKE-SHORT-METHOD-COMBINATION
    PCL::PLIST-MIXIN COMMON-LISP::SIMPLE-VECTOR PCL::CALL-SPEC
    PCL::*ENABLE-EMF-CALL-TRACING-P* PCL::CM-ARGS1
    PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS)|
    PCL::|(FAST-READER-METHOD SLOT-DEFINITION CLASS)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT CLASS)| SYSTEM::OBJECT
-   PCL::ARGUMENTS PCL::WRITER PCL::CACHE-NLINES PCL::*SLOTD-UNSUPPLIED*
-   COMMON-LISP::MACRO-FUNCTION PCL::DO-STANDARD-DEFSETF
-   PCL::|ARG-INFO SLOT9| PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION
-   PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
-   PCL::SLOT-DEFINITION-READER-FUNCTION
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT METHOD-CLASS)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
+   SYSTEM::OBJECT PCL::ARGUMENTS PCL::WRITER PCL::CACHE-NLINES
+   PCL::*SLOTD-UNSUPPLIED* COMMON-LISP::MACRO-FUNCTION
+   PCL::DO-STANDARD-DEFSETF PCL::|ARG-INFO SLOT9|
+   PCL::SLOT-DEFINITION-BOUNDP-FUNCTION
    PCL::SLOT-DEFINITION-WRITER-FUNCTION
-   PCL::SLOT-DEFINITION-BOUNDP-FUNCTION PCL::NEW-P PCL::METHOD-KEY
-   PCL::FSC-INSTANCE-WRAPPER PCL::EARLY-GF-NAME PCL::ALLOCATE-FUNCTION
-   PCL::TABLE-ENTRY PCL::OLD COMMON-LISP::UPGRADED-COMPLEX-PART-TYPE
-   PCL::CHECKING-DFUN-INFO PCL::COND-CLAUSES PCL::FROM-LINE
-   PCL::LINE-SEPARATION COMMON-LISP::PHASE CSTRUCT::C-CONS-CAR PCL::HIT
+   PCL::SLOT-DEFINITION-READER-FUNCTION
+   PCL::SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
+   PCL::SLOT-DEFINITION-INTERNAL-READER-FUNCTION PCL::NEW-P
+   PCL::METHOD-KEY PCL::FSC-INSTANCE-WRAPPER PCL::EARLY-GF-NAME
+   PCL::ALLOCATE-FUNCTION PCL::TABLE-ENTRY PCL::OLD
+   COMMON-LISP::UPGRADED-COMPLEX-PART-TYPE PCL::CHECKING-DFUN-INFO
+   PCL::COND-CLAUSES PCL::FROM-LINE PCL::LINE-SEPARATION
+   COMMON-LISP::PHASE CSTRUCT::C-CONS-CAR PCL::HIT
    PCL::*KEYWORD-PACKAGE*
-   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
    PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-   PCL::WHY PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
+   PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION PCL::WHY
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PV-CELL)|
    CSTRUCT::ADJUSTABLE-VECTOR COMMON-LISP::NBUTLAST
    PCL::CALL-NEXT-METHOD-BIND PCL::SLOT-INSTANCE
    PCL::|SYSTEM::S-DATA class predicate| PCL::CHECK-DOCUMENTATION
    COMMON-LISP::BIT PCL::DIRECT-SUPERCLASSES-P PCL::CONC-NAME
    PCL::SUPER-SLOTS PCL::NEXT-LINE COMMON-LISP::READ-LINE
-   PCL::RECOMP-REASONS PCL::SLOT-NAME PCL::SLOT-NAMES
+   PCL::RECOMP-REASONS PCL::SLOT-NAMES PCL::SLOT-NAME
    PCL::FIND-SUPERCLASS-CHAIN PCL::CHASE PCL::FAST-METHOD-CALL-FUNCTION
    PCL::|ARG-INFO SLOT8| CSTRUCT::C-SET-HASHTABLE-NENT PCL::PV-OFFSET
    PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAMED)|
@@ -3314,9 +3319,9 @@
    COMMON-LISP::*LOAD-PRINT* PCL::DFUN COMMON-LISP::CONCATENATE
    COMMON-LISP::&ALLOW-OTHER-KEYS COMMON-LISP::TREE-EQUAL
    COMMON-LISP::DEFINE-SYMBOL-MACRO
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SIZE)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT LINE-SIZE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SIZE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::SIZE)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT MASK)| PCL::CHECK-MEMBER
    PCL::COPY-INITIAL-DISPATCH PCL::MAKE-METHOD-FUNCTION
    PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-ENTRY-FN
@@ -3335,19 +3340,19 @@
    PCL::DNET-METHODS-P PCL::EARLY-P COMMON-LISP::CIS PCL::ACCESSOR
    PCL::MAP-PV-TABLE-REFERENCES-OF PCL::SLOT-DEFINITION-SIMPLE-TYPEP-FN
    PCL::|ARG-INFO SLOT6|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT NAME)|
-   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT DFUN-STATE)|
-   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-DEFINITION NAME)|
-   PCL::|(FAST-READER-METHOD CLASS NAME)|
-   PCL::|(FAST-READER-METHOD CLASS PREDICATE-NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT PREDICATE-NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAME)|
-   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)|
    PCL::|(FAST-READER-METHOD SLOT-OBJECT COMPILER::NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::CONC-NAME)| 
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SYSTEM::NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT PREDICATE-NAME)|
+   PCL::|(FAST-READER-METHOD CLASS PREDICATE-NAME)|
+   PCL::|(FAST-READER-METHOD CLASS NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-DEFINITION NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT SLOT-NAME)|
+   PCL::|(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-NAME)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT DFUN-STATE)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
+   PCL::|(FAST-READER-METHOD SLOT-OBJECT NAME)|
+   PCL::|(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
    COMMON-LISP::MERGE COMMON-LISP::CHAR> PCL::STRING-LOC
    CSTRUCT::C-ARRAY-ELTTYPE PCL::UNTRACE-METHOD PCL::BEEN-HERE
    PCL::MAIN-EFFECTIVE-METHOD COMMON-LISP::CHAR= PCL::AUGMENT-TYPE
@@ -3361,7 +3366,7 @@
    PCL::|ARG-INFO SLOT5| CSTRUCT::C-SET-T-MELTSIZE
    PCL::NO-CLASS-SLOTS-P PCL::INCLUDED-NAME PCL::SUPER
    PCL::MAKE-ONE-INDEX-DFUN-INFO COMMON-LISP::READ-BYTE
-   PCL::SPECIALIZED-POSITIONS PCL::SPECIALIZED-ARGUMENT-POSITIONS
+   PCL::SPECIALIZED-ARGUMENT-POSITIONS PCL::SPECIALIZED-POSITIONS
    COMMON-LISP::COMPILE-FILE PCL::PSYMS PCL::ARGLIST
    PCL::MAKE-METHOD-INITARGS-FORM COMMON-LISP::REQUIRE
    PCL::|(FAST-READER-METHOD SLOT-OBJECT LIMIT-FN)|
@@ -3404,11 +3409,11 @@
    COMMON-LISP::DELETE-IF-NOT PCL::SPECIALIZER-CACHE CSTRUCT::STRCAT
    PCL::CNM-ARGS PCL::PV-TABLE-CACHE COMMON-LISP::MEMBER-IF-NOT
    PCL::|COMPILER::FN SLOT6| PCL::VALUE-FOR-CACHING PCL::ADD-TO-CVECTOR
-   PCL::UNTRACE-1 PCL::MAKE-METHOD-FUNCTION-INTERNAL
-   PCL::MAKE-METHOD-LAMBDA-INTERNAL
-   PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL COMMON-LISP::LONG-FLOAT
-   COMMON-LISP::SIMPLE-VECTOR-P CSTRUCT::C-STREAM-MODE
-   PCL::DFUN-INFO-CACHE COMMON-LISP::ECHO-STREAM-INPUT-STREAM
+   PCL::UNTRACE-1 PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
+   PCL::MAKE-METHOD-LAMBDA-INTERNAL PCL::MAKE-METHOD-FUNCTION-INTERNAL
+   COMMON-LISP::LONG-FLOAT COMMON-LISP::SIMPLE-VECTOR-P
+   CSTRUCT::C-STREAM-MODE PCL::DFUN-INFO-CACHE
+   COMMON-LISP::ECHO-STREAM-INPUT-STREAM
    COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM
    CSTRUCT::C-SET-FUNCTION-MINARG COMMON-LISP::ARRAY-RANK
    COMMON-LISP::LAMBDA-PARAMETERS-LIMIT PCL::FIRST-FORM-TO-LISP
@@ -3419,11 +3424,11 @@
    PCL::GCL_PCL_ENV COMMON-LISP::DEFVAR PCL::WRAPPER-EQ
    PCL::LINE-FULL-P PCL::|COMPILER::FN SLOT5| PCL::FUNCALLABLE
    PCL::NO-OF-SLOTS COMMON-LISP::DEFSTRUCT
-   CSTRUCT::C-PACKAGE-EXTERNAL_SIZE PCL::.FUNCTION. PCL::CFUNCTION
-   PCL::TFUNCTION PCL::OFUNCTION PCL::DEFAULT-INITARGS-1
+   CSTRUCT::C-PACKAGE-EXTERNAL_SIZE PCL::OFUNCTION PCL::TFUNCTION
+   PCL::CFUNCTION PCL::.FUNCTION. PCL::DEFAULT-INITARGS-1
    COMMON-LISP::DEFINE-COMPILER-MACRO PCL::ARG-INFO
    PCL::|ARG-INFO SLOT0| PCL::FAST-METHOD-CALL-P
-   PCL::|(WRITER OPTIONS)| PCL::|(WRITER METHODS)| COMMON-LISP::BOOLEAN
+   PCL::|(WRITER METHODS)| PCL::|(WRITER OPTIONS)| COMMON-LISP::BOOLEAN
    CSTRUCT::C-SET-ADJARRAY-DISPLACED COMMON-LISP::SUBTYPEP
    PCL::%CHECK-CNM-ARGS CSTRUCT::C-CHARACTER-CODE
    PCL::STD-CLASS-SIMPLE-TYPEP-FN PCL::READER-SYMBOL
@@ -3431,50 +3436,49 @@
    CSTRUCT::*DOUBLE COMMON-LISP::EVERY PCL::METHOD-LAMBDA-ARGS
    PCL::ONE-INDEX-DFUN-INFO-INDEX CSTRUCT::C-FLOAT-FIXNUM->
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
-   PCL::INSTANCE-SLOTS PCL::OBJECTSP PCL::DFUN-INFO PCL::DFUN-INFO-
+   PCL::INSTANCE-SLOTS PCL::OBJECTSP PCL::DFUN-INFO- PCL::DFUN-INFO
    PCL::FILENAMES PCL::SETF-CASE
    COMMON-LISP::SIMPLE-CONDITION-FORMAT-ARGUMENTS
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::RAW)| PCL::KEY-NAMES
    PCL::MAKE-DEFMETHOD-FORM-INTERNAL PCL::ONE-INDEX-LIMIT-FN
-   PCL::|(WRITER DIRECT-SUPERCLASSES)|
-   PCL::|(WRITER DIRECT-SUBCLASSES)| COMMON-LISP::MAKE-ARRAY
+   PCL::|(WRITER DIRECT-SUBCLASSES)|
+   PCL::|(WRITER DIRECT-SUPERCLASSES)| COMMON-LISP::MAKE-ARRAY
    PCL::FAST-FUNCTION PCL::IGNORE3 PCL::|(WRITER BOUNDP-FUNCTION)|
    COMMON-LISP::COPY-STRUCTURE PCL::|COMPILER::FN SLOT3| PCL::PV-W-T
    PCL::MAP-SPECIALIZERS COMMON-LISP::SYNONYM-STREAM-SYMBOL
    COMMON-LISP::REMOVE-DUPLICATES PCL::.CONSTANT.
    PCL::INSTANCE-SLOT-INDEX CSTRUCT::C-SET-T-MELTMODE
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT SYSTEM::FROZEN)|
-   PCL::WALK-FUNCTION COMMON-LISP::SUBLIS PCL::STD-METHOD
-   PCL::STR-METHOD
-   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
+   PCL::WALK-FUNCTION COMMON-LISP::SUBLIS PCL::STR-METHOD
+   PCL::STD-METHOD PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VECTOR)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)| 
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT VECTOR)|
+   PCL::|(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
    PCL::GET-GENERIC-FUNCTION-INFO COMMON-LISP::DELETE-DUPLICATES
-   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITARGS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITARGS)|
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CALL-METHOD-ARGS)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::MACROS)|
-   PCL::|(WRITER DIRECT-METHODS)| PCL::|(WRITER DIRECT-SLOTS)|
-   PCL::NREQUIRED PCL::NREQUIREDS CSTRUCT::C-SET-HASHTABLE-RHTHRESH
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT CALL-METHOD-ARGS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITARGS)|
+   PCL::|(FAST-WRITER-METHOD SLOT-DEFINITION INITARGS)|
+   PCL::|(WRITER DIRECT-SLOTS)| PCL::|(WRITER DIRECT-METHODS)|
+   PCL::NREQUIREDS PCL::NREQUIRED CSTRUCT::C-SET-HASHTABLE-RHTHRESH
    PCL::ACCESSOR-VALUES1 PCL::SORTED-P COMMON-LISP::FUNCTION
    COMMON-LISP::FUNCTIONP
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OVERFLOW)| PCL::OLD-METHOD
    COMMON-LISP::REMOVE-IF PCL::LINE-2 PCL::PARAMETER-ENTRY
    COMMON-LISP::WHEN
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT COMPILER::ARG-TYPES)|
-   PCL::|(WRITER METHOD-COMBINATION)|
-   PCL::|(WRITER INTERNAL-READER-FUNCTION)|
    PCL::|(WRITER INTERNAL-WRITER-FUNCTION)|
-   PCL::FUN-TO-FUNCALLABLE-INSTANCE PCL::GET-METHOD PCL::NEW-METHOD
-   PCL::|COMPILER::FN SLOT2| PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS
-   PCL::RAND-BASE COMMON-LISP::ADJUSTABLE-ARRAY-P PCL::CLASSES-LIST
+   PCL::|(WRITER INTERNAL-READER-FUNCTION)|
+   PCL::|(WRITER METHOD-COMBINATION)| PCL::FUN-TO-FUNCALLABLE-INSTANCE
+   PCL::NEW-METHOD PCL::GET-METHOD PCL::|COMPILER::FN SLOT2|
+   PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::RAND-BASE
+   COMMON-LISP::ADJUSTABLE-ARRAY-P PCL::CLASSES-LIST
    PCL::RETURN-VALUE-P PCL::|(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)|
    PCL::.FAST-CALL-METHOD-LIST. PCL::METHOD-CALL-CALL-METHOD-ARGS
    PCL::|(WRITER METHOD-CLASS)| PCL::OPERATION-TRANSFORMATIONS
    PCL::IGNORE2 PCL::|(FAST-WRITER-METHOD SLOT-OBJECT NLINES)|
-   PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO| PCL::|__si::MAKE-DFUN-INFO|
-   PCL::|__si::MAKE-ARG-INFO| PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|
+   PCL::|__si::MAKE-ACCESSOR-DFUN-INFO| PCL::|__si::MAKE-ARG-INFO|
+   PCL::|__si::MAKE-DFUN-INFO| PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|
    PCL::METHOD-CALL COMMON-LISP::/// CSTRUCT::C-SET-PATHNAME-VERSION
    PCL::CPD-COUNT PCL::MODULE-P PCL::MAKE-INITIALIZE-INFO
    COMMON-LISP::APPEND PCL::|(FAST-WRITER-METHOD SLOT-OBJECT OWNER)|
@@ -3487,12 +3491,12 @@
    COMMON-LISP::HASH-TABLE-REHASH-SIZE PCL::|(WRITER FAST-FUNCTION)|
    PCL::MAKE-UNORDERED-METHODS-EMF PCL::WITH-LOCAL-CACHE-FUNCTIONS
    PCL::|COMPILER::FN SLOT1| PCL::METHOD-ALIST-P
-   COMMON-LISP::NAMESTRING PCL::FIN PCL::PROTO-GF
+   COMMON-LISP::NAMESTRING PCL::PROTO-GF PCL::FIN
    PCL::DEFINE-GF-PREDICATE CSTRUCT::C-FLOAT-DOUBLE-==
    PCL::|PCL::PLIST-MIXIN class predicate| PCL::AROUND
-   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
-   PCL::|(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
    PCL::|(FAST-WRITER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
+   PCL::|(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
+   PCL::|(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
    PCL::DO-WRITER-DEFINITION PCL::LEGAL-METHOD-FUNCTION-P
    PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::SO-FAR ITERATE::COLLECTING
    PCL::MAKE-READER-METHOD-FUNCTION PCL::IGNORE1 COMMON-LISP::VECTORP
--- gcl27-2.7.0.orig/unixport/boot.lisp
+++ gcl27-2.7.0/unixport/boot.lisp
@@ -1,4 +1,5 @@
 (in-package :compiler)(cdebug)(setq *compile-print* nil si::*notify-gbc* t *annotate* nil)
+(si::allocate 'structure 200 t)
 
 #+pre-gcl
 (progn
@@ -9,20 +10,33 @@
 
 (progn (setq si::*code-block-reserve* (make-array 30000000 :element-type 'character :static t)) nil)
 
-(mapc 'compile (nconc #-pre-gcl '(sbit si::aset si::improper-consp mapcar mapcan mapc mapl
+(mapc 'compile (nconc #+pre-gcl (progn 'si::(s-data-raw s-data-slot-position s-data-slot-descriptions))
+		      #-pre-gcl '(sbit si::aset si::improper-consp mapcar mapcan mapc mapl)
 					;maplist member member-if member-if-not
 					;assoc assoc-if assoc-if-not
 					;rassoc rassoc-if rassoc-if-not
-				  )
-		      #+pre-gcl '(si::s-data-raw si::s-data-slot-position si::s-data-slot-descriptions)
 		      '(info-p info-ref info-type info-flags info-ch info-ref-ccb info-ref-clb)
-		      '(var-p var-name var-flags var-kind var-ref var-ref-ccb var-loc var-dt var-type var-mt var-tag var-store)
-		      'si::(listp ibb ib typep <= coerce < > >= + - set-array 0-byte-array-self set-0-byte-array-self concatenate eql-is-eq)
+		      '(var-p var-name var-flags var-kind var-ref var-ref-ccb var-loc var-dt
+			var-type var-mt var-tag var-store)
+		      #-pre-gcl
+		      '(bit-andc2 bit-and bit-ior bit-xor bit-orc2 bit-not)
+		      #-pre-gcl
+		      (progn 'si::(copy-btp btp-equal one-bit-btp btp-count
+				     new-tp4 btp-type2 btp-bnds< btp-bnds>
+				     tp-and tp-or cmp-tp-not tp-not
+				     tp= tp-p))
+		      #-pre-gcl
+		      '(naltp explode-nalt needs-explode ctp-and ctp<=
+			type-and type-or1 type<= type>= type=)
+
+		      'si::(listp ibb ib typep <= coerce < > >= + -
+				  set-array 0-byte-array-self set-0-byte-array-self
+				  concatenate eql-is-eq)
 		      '(c1constant-value-object
 			c-array-rank c-array-dim c-array-elttype c-array-self c-array-hasfillp
 			array-dimension array-row-major-index row-major-aref si::row-major-aset
 			si::row-major-aref-int aref array-rank array-total-size
-			array-has-fill-pointer-p length memoized-hash-equal)))
+			array-has-fill-pointer-p length)))
 
 (in-package :user)
 
--- gcl27-2.7.0.orig/unixport/makefile
+++ gcl27-2.7.0/unixport/makefile
@@ -24,7 +24,10 @@ endif
 LD_LIBS_PRE=$(addprefix -u ,$(PATCHED_SYMBOLS))
 LD_LIBS_POST=$(LIBS) $(LIBC) -lgclp
 ifneq ($(LAST_FILE),)
-LD_LIBS_POST:=$(LD_LIBS_POST) $(ODIR)/$(LAST_FILE)
+LD_LIBS_POST:=$(LD_LIBS_POST) ../o/boot.o $(ODIR)/$(LAST_FILE)
+LIBBOOT:=
+else
+LIBBOOT:=libboot.so
 endif
 
 ifeq ($(ARRS),)
@@ -118,7 +121,7 @@ $(HDIR)/mdefs.h: $(HDIR)/include.h
 sys_%.o: sys_init.c sys.c
 	$(CC) $(CFLAGS) -c -D $* -D FLAVOR="$*" $< -o $@
 
-libpre_gcl.a: $(OOBJS) sys_pre_gcl.o gmpfiles libboot.so
+libpre_gcl.a: $(OOBJS) sys_pre_gcl.o gmpfiles $(LIBBOOT)
 	rm -rf $@
 	$(ARRS) $@ $(filter %.o,$^) $(shell find gmp -name "*.o")
 
--- gcl27-2.7.0.orig/xgcl-2/makefile
+++ gcl27-2.7.0/xgcl-2/makefile
@@ -6,7 +6,7 @@ LISP?=$(shell echo $$(pwd)/../unixport/s
 APPEND=../xbin/append
 
 objects: $(shell ls -1 *.c *.o) #$(LISP)
-	echo '(load "sysdef.lisp")(load "sys-proclaim.lisp")(compiler::cdebug)(xlib::compile-xgcl)' | $(LISP)
+	echo '#+xgcl(load "sysdef.lisp")#+xgcl(progn(load "sys-proclaim.lisp")(compiler::cdebug)(xlib::compile-xgcl))' | $(LISP)
 	touch $@
 
 gprof_objs: objects $(addprefix ../gprof/,$(shell ls -1 *.o))
@@ -18,14 +18,14 @@ gprof_objs: objects $(addprefix ../gprof
 
 
 sys-proclaim.lisp:
-	echo '(load "sysdef.lisp")(compiler::emit-fn t)(xlib::compile-xgcl)(compiler::make-all-proclaims "*.fn")' | $(LISP)
+	echo '#+xgcl(load "sysdef.lisp")#+xgcl(progn(compiler::emit-fn t)(xlib::compile-xgcl)(compiler::make-all-proclaims "*.fn"))' | $(LISP)
 
 docs: dwdoc/dwdoccontents.html dwdoc.pdf
 
 dwdoc/dwdoccontents.html: $(LISP)
 	mkdir -p $(@D) && \
 	cd $(@D) && \
-	echo '(load "../sysdef.lisp")(in-package :xlib)(defmacro while (test &rest forms) `(loop (unless ,test (return)) ,@forms))(load "../gcl_tohtml.lsp")(load "../gcl_index.lsp")(tohtml "../dwdoc.tex" "dwdoc")(with-open-file (s "dwdoccontents.html" :direction :output) (let ((*standard-output* s)) (xlib::makecont "../dwdoc.tex" 1 "dwdoc")))(with-open-file (s "dwdocindex.html" :direction :output) (let ((*standard-output* s)) (xlib::printindex indexdata "dwdoc")))' | $<
+	echo '#+xgcl(load "../sysdef.lisp")#+xgcl(in-package :xlib)#+xgcl(progn(defmacro while (test &rest forms) `(loop (unless ,test (return)) ,@forms))(load "../gcl_tohtml.lsp")(load "../gcl_index.lsp")(tohtml "../dwdoc.tex" "dwdoc")(with-open-file (s "dwdoccontents.html" :direction :output) (let ((*standard-output* s)) (xlib::makecont "../dwdoc.tex" 1 "dwdoc")))(with-open-file (s "dwdocindex.html" :direction :output) (let ((*standard-output* s)) (xlib::printindex indexdata "dwdoc"))))' | $<
 
 dwdoc.pdf: dwdoc.tex
 	-pdflatex $<
