<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.

gcl (2.6.12-43) unstable; urgency=medium

  * pathnames1.7

Gbp-Pq: Name pathnames1.9

diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp
index 6f84d2c01a969955a5501006030a862b8a9e8cc5..cf1a831e7fc93817c64e36819c1bb9e8185a74cd 100644 (file)
--- a/ansi-tests/ansi-aux.lsp
+++ b/ansi-tests/ansi-aux.lsp
@@ -1635,3 +1635,6 @@ the condition to go uncaught if it cannot be classified."
 
 (defmacro expand-in-current-env (macro-form &environment env)
   (macroexpand macro-form env))
+
+(defun typep* (element type)
+  (not (not (typep element type))))

diff --git a/clcs/sys-proclaim.lisp b/clcs/sys-proclaim.lisp
index 1faff6330f9816e3713e995a48f8ee583d04bfc4..267e206ac1eefcb1db622d0cfc2d8c84fff4eee5 100644 (file)
--- a/clcs/sys-proclaim.lisp
+++ b/clcs/sys-proclaim.lisp
@@ -2,30 +2,14 @@
 (COMMON-LISP::IN-PACKAGE "CONDITIONS") 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
-         CONDITIONS::IS-WARNING CONDITIONS::DEFAULT-REPORT
-         CONDITIONS::IS-CONDITION CONDITIONS::CONDITIONP)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::T)
+         CONDITIONS::COERCE-TO-FN CONDITIONS::SLOT-SYM)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::*)
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ARITHMETIC-ERROR T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PACKAGE-ERROR T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (INTERNAL-CONDITION T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNDEFINED-FUNCTION T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-SLOT T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-VARIABLE T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CASE-FAILURE T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PRINT-NOT-READABLE T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (SIMPLE-CONDITION T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ABORT-FAILURE T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (TYPE-ERROR T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CELL-ERROR T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (FILE-ERROR T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (END-OF-FILE T))|
-         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (STREAM-ERROR T))|)) 
+         COMMON-LISP::MAKE-CONDITION)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
@@ -36,11 +20,27 @@
          CONDITIONS::|(PCL::FAST-METHOD MAKE-LOAD-FORM (CONDITION))|)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         CONDITIONS::COERCE-TO-FN CONDITIONS::SLOT-SYM)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
+         CONDITIONS::IS-CONDITION CONDITIONS::DEFAULT-REPORT
+         CONDITIONS::IS-WARNING CONDITIONS::CONDITIONP)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
              COMMON-LISP::*)
-         COMMON-LISP::MAKE-CONDITION)) 
\ No newline at end of file
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PACKAGE-ERROR T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CASE-FAILURE T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ABORT-FAILURE T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (FILE-ERROR T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-VARIABLE T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (ARITHMETIC-ERROR T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (END-OF-FILE T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (STREAM-ERROR T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (CELL-ERROR T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (SIMPLE-CONDITION T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNBOUND-SLOT T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (UNDEFINED-FUNCTION T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (INTERNAL-CONDITION T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (PRINT-NOT-READABLE T))|
+         CONDITIONS::|(PCL::FAST-METHOD PRINT-OBJECT (TYPE-ERROR T))|)) 
\ No newline at end of file

diff --git a/cmpnew/gcl_cmpmain.lsp b/cmpnew/gcl_cmpmain.lsp
index 39558120872e7cbbca497dea5f7ba5e493d5c3c3..4552326b988a96e0fa5b4735bd3b9a6bd41c702d 100755 (executable)
--- a/cmpnew/gcl_cmpmain.lsp
+++ b/cmpnew/gcl_cmpmain.lsp
@@ -430,7 +430,7 @@ Cannot compile ~a.~%"
                             (si::copy-stream st *standard-output*))
             (with-open-file (st hn)
                             (si::copy-stream st *standard-output*))
-            (when (eql (aref *objdump* 0) #\/);program found at startup in path
+            (when *objdump*
               (safe-system (si::string-concatenate *objdump* (namestring on))))
             (mdelete-file cn)
             (mdelete-file dn)

diff --git a/cmpnew/gcl_lfun_list.lsp b/cmpnew/gcl_lfun_list.lsp
index e2b1262dc44a804f18bc14040d81e0dab5ff376d..4b46f923cf403f8ad2e3fb1ab7a2192c21c9e6c2 100755 (executable)
--- a/cmpnew/gcl_lfun_list.lsp
+++ b/cmpnew/gcl_lfun_list.lsp
@@ -43,7 +43,6 @@
 (DEFSYSFUN 'RASSOC "Lrassoc" '(T T *) 'T NIL NIL) 
 (DEFSYSFUN 'PPRINT "Lpprint" '(T *) 'T NIL NIL) 
 (DEFSYSFUN 'NSUBST-IF-NOT "Lnsubst_if_not" '(T T T *) 'T NIL NIL) 
-(DEFSYSFUN 'FILE-POSITION "Lfile_position" '(T *) 'T NIL NIL) 
 (DEFSYSFUN 'STRING< "Lstring_l" '(T T *) 'T NIL NIL) 
 (DEFSYSFUN 'REVERSE "Lreverse" '(T) 'T NIL NIL) 
 (DEFSYSFUN 'STREAMP "Lstreamp" '(T) 'T NIL T) 
@@ -67,7 +66,6 @@
 (DEFSYSFUN 'CONS "Lcons" '(T T) 'T NIL NIL) 
 (DEFSYSFUN 'LIST "Llist" '(*) 'T NIL NIL) 
 (DEFSYSFUN 'USE-PACKAGE "Luse_package" '(T *) 'T NIL NIL) 
-(DEFSYSFUN 'FILE-LENGTH "Lfile_length" '(T) 'T NIL NIL) 
 (DEFSYSFUN 'MAKE-SYMBOL "Lmake_symbol" '(T) 'T NIL NIL) 
 (DEFSYSFUN 'STRING-RIGHT-TRIM "Lstring_right_trim" '(T T) 'STRING NIL
     NIL) 

diff --git a/cmpnew/sys-proclaim.lisp b/cmpnew/sys-proclaim.lisp
index 32afb65b1dfc4c9e2d45a9e48cabfe63724caae3..52155946947d530d58d0c829d0605451faa3f9a9 100755 (executable)
--- a/cmpnew/sys-proclaim.lisp
+++ b/cmpnew/sys-proclaim.lisp
@@ -1,377 +1,395 @@
 
 (COMMON-LISP::IN-PACKAGE "COMPILER") 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::STRING COMMON-LISP::*)
-             COMMON-LISP::T)
-         COMPILER::TS)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
-         COMPILER::C1MULTIPLE-VALUE-BIND COMPILER::C1VALUES
-         COMPILER::C1RPLACA COMPILER::FUN-P
-         COMPILER::FUNCTION-ARG-TYPES COMPILER::C1STRUCTURE-REF
-         COMPILER::GET-RETURN-TYPE COMPILER::WT-FUNCALL-C
-         COMPILER::MACRO-DEF-P COMPILER::T1DEFUN COMPILER::C1ASSOC
-         COMPILER::SET-UP-VAR-CVS COMPILER::C2FUNCTION
-         COMPILER::C1DM-BAD-KEY COMPILER::ADD-OBJECT
-         COMPILER::WT-SWITCH-CASE COMPILER::VARARG-P
-         COMPILER::C1TAGBODY COMPILER::C2GET COMPILER::VAR-REF
-         COMPILER::SCH-LOCAL-FUN COMPILER::ADD-SYMBOL
-         COMPILER::TAG-UNWIND-EXIT COMPILER::C1MULTIPLE-VALUE-SETQ
-         COMPILER::C1PRINC COMPILER::WT-VAR-DECL COMPILER::C1QUOTE
-         COMPILER::C2RPLACD COMPILER::CHECK-VREF
-         COMPILER::PUSH-ARGS-LISPCALL COMPILER::C1MAPLIST
-         COMPILER::ADD-REG1 COMPILER::C1OR COMPILER::WT-SYMBOL-FUNCTION
-         COMPILER::TAG-P COMPILER::SAFE-SYSTEM COMPILER::C1ECASE
-         COMPILER::LTVP COMPILER::GET-INCLUDED COMPILER::INFO-P
-         COMPILER::FUN-INFO COMPILER::C1LOAD-TIME-VALUE
-         COMPILER::GET-LOCAL-ARG-TYPES COMPILER::BLK-P
-         COMPILER::BLK-EXIT COMPILER::C2VAR-KIND COMPILER::C2LOCATION
-         COMPILER::WT1 COMPILER::WT-CCB-VS
-         COMPILER::WT-DOWNWARD-CLOSURE-MACRO COMPILER::BLK-REF-CCB
-         COMPILER::UNDEFINED-VARIABLE COMPILER::C1MULTIPLE-VALUE-CALL
-         COMPILER::VAR-LOC COMPILER::C1SETQ COMPILER::C1NTH-CONDITION
-         COMPILER::C2RPLACA COMPILER::FUN-REF COMPILER::C2VAR
-         COMPILER::WT-CAR COMPILER::WT-LIST COMPILER::WRITE-BLOCK-OPEN
-         COMPILER::INFO-VOLATILE COMPILER::GET-LOCAL-RETURN-TYPE
-         COMPILER::AET-C-TYPE COMPILER::PUSH-ARGS COMPILER::TAG-REF-CLB
-         COMPILER::BLK-REF COMPILER::VAR-P COMPILER::C1ADD-GLOBALS
-         COMPILER::T3ORDINARY COMPILER::ADD-OBJECT2 COMPILER::SET-TOP
-         COMPILER::T1DEFLA COMPILER::C1FUNCTION COMPILER::T3CLINES
-         COMPILER::T1DEFCFUN COMPILER::C1VREF COMPILER::C1ASH
-         COMPILER::BLK-NAME COMPILER::WT-CADR COMPILER::WT-DOWN
-         COMPILER::C1TERPRI COMPILER::C2GETHASH COMPILER::C2GO-CCB
-         COMPILER::SAVE-FUNOB COMPILER::T2DECLARE COMPILER::FUN-REF-CCB
-         COMPILER::C1MAPCAR COMPILER::T1DEFMACRO
-         COMPILER::C2TAGBODY-LOCAL COMPILER::C1STACK-LET
-         COMPILER::INFO-TYPE COMPILER::T1MACROLET COMPILER::C1LET*
-         COMPILER::C1RPLACD COMPILER::DECLARATION-TYPE
-         COMPILER::T1ORDINARY COMPILER::C2EXPR* COMPILER::C1LOCAL-FUN
-         COMPILER::WT-DATA-PACKAGE-OPERATION
-         COMPILER::C1BOOLE-CONDITION SYSTEM::UNDEF-COMPILER-MACRO
-         COMPILER::C2TAGBODY-BODY COMPILER::C1NTHCDR COMPILER::C1VAR
-         COMPILER::C1MULTIPLE-VALUE-PROG1 COMPILER::C1NTHCDR-CONDITION
-         COMPILER::CONSTANT-FOLD-P COMPILER::C1UNWIND-PROTECT
-         COMPILER::PROCLAMATION COMPILER::C1NTH COMPILER::C1RETURN-FROM
-         COMPILER::INFO-SP-CHANGE COMPILER::C1LENGTH
-         COMPILER::CMP-MACRO-FUNCTION COMPILER::BLK-REF-CLB
-         COMPILER::NAME-TO-SD COMPILER::CTOP-WRITE COMPILER::C1MAPCON
-         COMPILER::C1FUNOB COMPILER::FIX-OPT COMPILER::C1RPLACA-NTHCDR
-         COMPILER::C1FLET COMPILER::RESULT-TYPE COMPILER::C1CATCH
-         COMPILER::C2DM-RESERVE-V COMPILER::VAR-NAME
-         COMPILER::CMP-MACROEXPAND COMPILER::VERIFY-DATA-VECTOR
-         COMPILER::T1CLINES COMPILER::C1MAPL COMPILER::T1DEFENTRY
-         COMPILER::TAG-REF-CCB COMPILER::WT-VS
-         COMPILER::LONG-FLOAT-LOC-P COMPILER::C1MAPCAN
-         COMPILER::OBJECT-TYPE COMPILER::ADD-ADDRESS
-         COMPILER::RESET-INFO-TYPE COMPILER::C1BOOLE3 COMPILER::C1MEMQ
-         COMPILER::C1DEFINE-STRUCTURE COMPILER::TYPE-FILTER
-         COMPILER::UNWIND-NO-EXIT COMPILER::C1FMLA-CONSTANT
-         COMPILER::C2DM-RESERVE-VL COMPILER::C1FSET COMPILER::LTVP-EVAL
-         COMPILER::C1GO COMPILER::WT-VV COMPILER::INFO-CHANGED-ARRAY
-         COMPILER::C1FUNCALL COMPILER::C2TAGBODY-CCB
-         COMPILER::TAG-LABEL COMPILER::VAR-KIND COMPILER::WT-VS*
-         COMPILER::VAR-TYPE COMPILER::C2GO-LOCAL COMPILER::REGISTER
-         COMPILER::T1PROGN COMPILER::C1BLOCK COMPILER::TAG-SWITCH
-         COMPILER::VAR-REP-LOC COMPILER::C2BIND
-         COMPILER::SET-PUSH-CATCH-FRAME COMPILER::COPY-INFO
-         COMPILER::C1LIST-NTH COMPILER::CONS-TO-LISTA
-         COMPILER::FUN-LEVEL COMPILER::C1DOWNWARD-FUNCTION
-         COMPILER::THE-PARAMETER COMPILER::C2VALUES COMPILER::C1LABELS
-         COMPILER::MAXARGS COMPILER::VAR-REF-CCB COMPILER::MDELETE-FILE
-         COMPILER::WT-FUNCTION-LINK COMPILER::SAVE-AVMA
-         COMPILER::VOLATILE COMPILER::ADD-CONSTANT COMPILER::C1APPLY
-         COMPILER::C1GETHASH COMPILER::FUN-NAME COMPILER::DEFAULT-INIT
-         COMPILER::CLINK COMPILER::WT-CDR COMPILER::PARSE-CVSPECS
-         COMPILER::REP-TYPE COMPILER::C2GO-CLB
-         COMPILER::ARGS-CAUSE-SIDE-EFFECT COMPILER::PUSH-DATA-INCF
-         COMPILER::SCH-GLOBAL COMPILER::C1STRUCTURE-SET
-         COMPILER::TAG-NAME COMPILER::INFO-REFERRED-ARRAY
-         COMPILER::C1EXPR COMPILER::C1GET COMPILER::BLK-VAR
-         COMPILER::TAG-REF COMPILER::C1MAPC COMPILER::SET-RETURN
-         COMPILER::SHORT-FLOAT-LOC-P COMPILER::C1DECLARE
-         COMPILER::WT-DATA1 COMPILER::FLAGS-POS
-         COMPILER::BLK-VALUE-TO-GO COMPILER::NAME-SD1
-         COMPILER::C2DOWNWARD-FUNCTION COMPILER::C1SHARP-COMMA
-         COMPILER::INLINE-POSSIBLE COMPILER::WT-H1
-         COMPILER::FIXNUM-LOC-P COMPILER::C1LET COMPILER::C1IF
-         COMPILER::C1THE COMPILER::FUNCTION-RETURN-TYPE
-         COMPILER::GET-ARG-TYPES COMPILER::INLINE-TYPE
-         COMPILER::FUN-CFUN COMPILER::TAG-VAR COMPILER::CHARACTER-LOC-P
-         COMPILER::CHECK-DOWNWARD COMPILER::C1PSETQ
-         COMPILER::INLINE-BOOLE3-STRING COMPILER::C1THROW
-         COMPILER::FSET-FN-NAME COMPILER::T1DEFINE-STRUCTURE
-         COMPILER::NEED-TO-SET-VS-POINTERS COMPILER::C1PROGN
-         COMPILER::C2FUNCALL-AUX COMPILER::C1MACROLET COMPILER::C1AND
-         COMPILER::WT-VS-BASE COMPILER::ADD-LOOP-REGISTERS
-         COMPILER::VAR-REGISTER COMPILER::C1PROGV COMPILER::C1SWITCH
-         COMPILER::C1MEMBER COMPILER::C2TAGBODY-CLB
-         COMPILER::CMP-MACROEXPAND-1 COMMON-LISP::PROCLAIM
-         COMPILER::C1ASH-CONDITION COMPILER::C1EVAL-WHEN
-         COMPILER::C1LOCAL-CLOSURE COMPILER::REPLACE-CONSTANT)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*)
-         COMPILER::INLINE-BOOLE3)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
-             COMMON-LISP::*)
-         COMPILER::C2DM COMPILER::C1DM-V COMPILER::C1DM-VL
-         COMPILER::C2RETURN-FROM COMPILER::C2APPLY-OPTIMIZE)) 
+             ((COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807)
+              (COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807))
+             COMMON-LISP::T)
+         COMPILER::MLIN)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         COMPILER::WT-INLINE COMPILER::C2IF COMPILER::C2LABELS
-         COMPILER::C2FLET)) 
+             ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER
+                  COMMON-LISP::*)
+              (COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807)
+              (COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807))
+             COMMON-LISP::T)
+         COMPILER::DASH-TO-UNDERSCORE-INT)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::*)
-         COMPILER::T3DEFUN-AUX)) 
+             ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER
+                  COMMON-LISP::*))
+             COMMON-LISP::T)
+         COMPILER::TS COMPILER::DASH-TO-UNDERSCORE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM)
-         COMPILER::F-TYPE)) 
+         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T)
+         COMPILER::C1NIL COMPILER::WT-DATA-FILE
+         COMPILER::CLOSE-INLINE-BLOCKS COMPILER::WT-NEXT-VAR-ARG
+         COMPILER::RESET-TOP COMPILER::VS-PUSH COMPILER::BABOON
+         COMPILER::GAZONK-NAME COMPILER::PRINT-COMPILER-INFO
+         COMPILER::ADD-LOAD-TIME-SHARP-COMMA COMPILER::INIT-ENV
+         COMPILER::PRINT-CURRENT-FORM COMPILER::WT-C-PUSH COMPILER::C1T
+         COMPILER::WT-FIRST-VAR-ARG COMPILER::CCB-VS-PUSH
+         COMPILER::INC-INLINE-BLOCKS COMPILER::WT-CVARS
+         COMPILER::WT-FASD-DATA-FILE COMPILER::WFS-ERROR
+         COMPILER::WT-DATA-END COMPILER::TAIL-RECURSION-POSSIBLE
+         COMPILER::CVS-PUSH COMPILER::WT-DATA-BEGIN)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::STRING) COMMON-LISP::T)
-         COMPILER::DASH-TO-UNDERSCORE)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::FIXNUM)
+         COMPILER::ANALYZE-REGS1 COMPILER::ANALYZE-REGS
+         COMPILER::PROCLAIMED-ARGD)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         COMPILER::INIT-NAME COMPILER::ADD-INIT COMPILER::C1LAMBDA-EXPR
-         COMPILER::WT-CVAR COMPILER::C1CASE COMPILER::WT-COMMENT
-         COMPILER::CMPERR COMPILER::WT-INTEGER-LOC COMPILER::CMPNOTE
-         COMPILER::FAST-LINK-PROCLAIMED-TYPE-P COMPILER::UNWIND-EXIT
-         COMPILER::CMPWARN)) 
+         COMPILER::CHECK-FNAME-ARGS COMPILER::COERCE-LOC
+         COMPILER::TYPE>= COMPILER::C2BIND-LOC
+         COMPILER::RESULT-TYPE-FROM-ARGS COMPILER::ADD-DEBUG-INFO
+         COMPILER::MAKE-USER-INIT COMPILER::CO1EQL COMPILER::C2ASSOC!2
+         COMPILER::WT-VAR COMPILER::CFAST-WRITE COMPILER::C2STACK-LET
+         COMPILER::C2DM-BIND-INIT COMPILER::IS-REP-REFERRED
+         COMPILER::CO1CONS COMPILER::SHIFT<<
+         COMPILER::C2MULTIPLE-VALUE-SETQ COMPILER::C2CALL-LOCAL
+         COMPILER::CO1SCHAR COMPILER::C1CONSTANT-VALUE
+         COMPILER::WT-CHARACTER-VALUE COMPILER::CONVERT-CASE-TO-SWITCH
+         COMPILER::C2MULTIPLE-VALUE-CALL COMPILER::C2EXPR-TOP
+         COMPILER::CO1READ-BYTE COMPILER::PRIN1-CMP
+         COMPILER::STRUCT-TYPE-OPT COMPILER::C1DECL-BODY
+         COMPILER::COERCE-LOC-STRUCTURE-REF
+         COMPILER::CO1STRUCTURE-PREDICATE COMPILER::WT-MAKE-DCLOSURE
+         COMPILER::ARGS-INFO-CHANGED-VARS
+         COMPILER::C2LIST-NTH-IMMEDIATE COMPILER::CO1LDB
+         COMPILER::CO1WRITE-BYTE COMPILER::C1PROGN*
+         COMPILER::CO1CONSTANT-FOLD COMPILER::SET-JUMP-TRUE
+         COMPILER::C1SETQ1 COMPILER::CO1READ-CHAR COMPILER::C2BIND-INIT
+         COMPILER::CO1TYPEP COMPILER::WT-FIXNUM-VALUE
+         COMPILER::MULTIPLE-VALUE-CHECK COMPILER::SHIFT>>
+         COMPILER::CO1SUBLIS COMPILER::DO-MACRO-EXPANSION
+         COMPILER::C2UNWIND-PROTECT COMPILER::C2CALL-LAMBDA
+         COMPILER::C2MEMBER!2 COMPILER::GET-INLINE-LOC
+         COMPILER::C1LAMBDA-FUN COMPILER::JUMPS-TO-P COMPILER::C1EXPR*
+         COMPILER::C2SETQ COMPILER::C2APPLY COMPILER::UNWIND-BDS
+         COMPILER::SET-BDS-BIND COMPILER::NEED-TO-PROTECT
+         COMPILER::C1FMLA COMPILER::TYPE-AND COMPILER::CMPFIX-ARGS
+         COMPILER::MAYBE-EVAL COMPILER::C2BLOCK-CLB COMPILER::SET-DBIND
+         COMPILER::C2LAMBDA-EXPR-WITHOUT-KEY
+         COMPILER::WT-LONG-FLOAT-VALUE COMPILER::C2DM-BIND-VL
+         COMPILER::WT-SHORT-FLOAT-VALUE COMPILER::T3SHARP-COMMA
+         COMPILER::COMPILER-CLEAR-COMPILER-PROPERTIES COMPILER::C2CATCH
+         COMPILER::C2EXPR-TOP* COMPILER::SET-JUMP-FALSE
+         COMPILER::CO1VECTOR-PUSH COMPILER::WT-V*-MACROS
+         COMPILER::ARGS-INFO-REFERRED-VARS COMPILER::SET-VS
+         COMPILER::WT-REQUIREDS COMPILER::C2RETURN-CCB
+         COMPILER::C2THROW COMPILER::CHECK-END
+         COMPILER::PUSH-CHANGED-VARS COMPILER::C2BLOCK-CCB
+         SYSTEM::ADD-DEBUG COMPILER::C2PSETQ COMPILER::C1ARGS
+         COMPILER::COMPILER-CC COMPILER::INLINE-PROC
+         COMPILER::CO1WRITE-CHAR COMPILER::COMPILER-DEF-HOOK
+         COMPILER::CAN-BE-REPLACED COMPILER::C2MULTIPLE-VALUE-PROG1
+         COMPILER::C2DM-BIND-LOC COMPILER::ADD-INFO
+         COMPILER::CO1SPECIAL-FIX-DECL COMPILER::C2LAMBDA-EXPR-WITH-KEY
+         COMPILER::FAST-READ COMPILER::C2RETURN-CLB
+         COMPILER::PROCLAIM-VAR)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::*)
-         COMPILER::C2RETURN-LOCAL COMPILER::C2BLOCK-LOCAL
-         COMPILER::NCONC-FILES COMPILER::C1SYMBOL-FUN COMPILER::C2BLOCK
-         COMPILER::C1BODY COMPILER::COMPILER-BUILD
-         COMPILER::C2DECL-BODY COMPILER::WT-INLINE-LOC)) 
-(COMMON-LISP::MAPC
-    (COMMON-LISP::LAMBDA (COMPILER::X)
-      (COMMON-LISP::SETF
-          (COMMON-LISP::GET COMPILER::X 'SYSTEM::PROCLAIMED-CLOSURE)
-          COMMON-LISP::T))
-    '(COMPILER::CMP-ANON COMMON-LISP::COMPILE COMPILER::CMP-TMP-MACRO
-         COMMON-LISP::DISASSEMBLE)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T (COMMON-LISP::VECTOR COMMON-LISP::T)
-                 COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM
-                 COMMON-LISP::T)
-             COMMON-LISP::FIXNUM)
-         COMPILER::BSEARCHLEQ)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T (COMMON-LISP::VECTOR COMMON-LISP::T)
-                 COMMON-LISP::FIXNUM COMMON-LISP::T)
-             COMMON-LISP::FIXNUM)
-         COMPILER::PUSH-ARRAY)) 
+         COMPILER::COMPILE-FILE1)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         COMPILER::AND-FORM-TYPE COMPILER::SET-VAR COMPILER::C2LET*
-         COMPILER::COMPILER-PASS2 COMPILER::ADD-FUNCTION-DECLARATION
-         COMPILER::BOOLE3 COMPILER::C1MAP-FUNCTIONS
-         COMPILER::TOO-MANY-ARGS COMPILER::CHECK-FORM-TYPE
-         COMPILER::C2LET COMPILER::C-FUNCTION-NAME
-         COMPILER::WT-INLINE-SHORT-FLOAT COMPILER::FIX-DOWN-ARGS
-         COMPILER::C2PRINC COMPILER::WT-IF-PROCLAIMED
-         COMPILER::ADD-FAST-LINK COMPILER::C2MULTIPLE-VALUE-BIND
-         COMPILER::C2MAPCAN COMPILER::CJT COMPILER::CHECK-VDECL
-         COMPILER::INLINE-TYPE-MATCHES COMPILER::WT-INLINE-LONG-FLOAT
-         COMPILER::C2GO COMPILER::CAN-BE-REPLACED* COMPILER::MYSUB
-         COMPILER::ASSIGN-DOWN-VARS COMPILER::C2MAPC
-         COMPILER::WT-INLINE-INTEGER COMPILER::GET-INLINE-INFO
-         COMPILER::CJF COMPILER::TOO-FEW-ARGS COMPILER::T3DEFCFUN
-         COMPILER::CMP-EXPAND-MACRO COMPILER::WT-MAKE-CCLOSURE
-         COMPILER::C2FUNCALL-SFUN COMPILER::C1DM
-         COMPILER::WT-INLINE-COND COMPILER::C2TAGBODY
-         COMPILER::WT-INLINE-CHARACTER COMPILER::C2PROGV
-         COMPILER::C2MAPCAR COMPILER::C1STRUCTURE-REF1 COMPILER::C2CASE
-         COMPILER::ADD-FUNCTION-PROCLAMATION
-         COMPILER::MAKE-INLINE-STRING COMPILER::SUBLIS1-INLINE
-         COMPILER::WT-INLINE-FIXNUM)) 
+         COMPILER::MAKE-INLINE-STRING COMPILER::GET-INLINE-INFO
+         COMPILER::C1STRUCTURE-REF1 COMPILER::CJF COMPILER::SET-VAR
+         COMPILER::CHECK-FORM-TYPE COMPILER::AND-FORM-TYPE
+         COMPILER::SUBLIS1-INLINE COMPILER::T3DEFCFUN
+         COMPILER::WT-INLINE-INTEGER COMPILER::C-FUNCTION-NAME
+         COMPILER::FIX-DOWN-ARGS COMPILER::ASSIGN-DOWN-VARS
+         COMPILER::WT-INLINE-FIXNUM COMPILER::C2GO COMPILER::CJT
+         COMPILER::TOO-FEW-ARGS COMPILER::C2PRINC COMPILER::C2CASE
+         COMPILER::C2LET* COMPILER::BOOLE3 COMPILER::COMPILER-PASS2
+         COMPILER::C1DM COMPILER::CHECK-VDECL COMPILER::C2LET
+         COMPILER::MYSUB COMPILER::CAN-BE-REPLACED*
+         COMPILER::ADD-FUNCTION-PROCLAMATION COMPILER::WT-IF-PROCLAIMED
+         COMPILER::C1MAP-FUNCTIONS COMPILER::ADD-FAST-LINK
+         COMPILER::WT-INLINE-LONG-FLOAT COMPILER::TOO-MANY-ARGS
+         COMPILER::C2MULTIPLE-VALUE-BIND COMPILER::C2PROGV
+         COMPILER::WT-INLINE-CHARACTER
+         COMPILER::ADD-FUNCTION-DECLARATION COMPILER::CMP-EXPAND-MACRO
+         COMPILER::C2MAPCAR COMPILER::INLINE-TYPE-MATCHES
+         COMPILER::C2FUNCALL-SFUN COMPILER::WT-MAKE-CCLOSURE
+         COMPILER::C2MAPCAN COMPILER::C2TAGBODY
+         COMPILER::WT-INLINE-COND COMPILER::C2MAPC
+         COMPILER::WT-INLINE-SHORT-FLOAT)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
-         COMPILER::C2LAMBDA-EXPR COMPILER::C2FUNCALL COMPILER::LINK
-         COMPILER::INLINE-ARGS)) 
+         COMPILER::T3LOCAL-FUN COMPILER::T3LOCAL-DCFUN)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         COMPILER::C2STRUCTURE-REF COMPILER::WT-GLOBAL-ENTRY
-         COMPILER::T3DEFUN-VARARG COMPILER::T3DEFUN-NORMAL
-         COMPILER::C2CALL-GLOBAL COMPILER::C1MAKE-VAR
-         COMPILER::C2CALL-UNKNOWN-GLOBAL COMPILER::C2SWITCH
-         COMPILER::T3INIT-FUN COMPILER::MY-CALL)) 
+         COMPILER::T3DEFMACRO COMPILER::T3DEFENTRY COMPILER::T2DEFENTRY
+         COMPILER::DEFSYSFUN COMPILER::T2DEFMACRO)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+                 COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         COMPILER::DEFSYSFUN COMPILER::T2DEFMACRO COMPILER::T2DEFENTRY
-         COMPILER::T3DEFMACRO COMPILER::T3DEFENTRY)) 
+         COMPILER::T3DEFUN COMPILER::T3DEFUN-LOCAL-ENTRY
+         COMPILER::C2STRUCTURE-SET COMPILER::T2DEFUN
+         COMPILER::C1APPLY-OPTIMIZE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T)
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
-         COMPILER::T2DEFUN COMPILER::C1APPLY-OPTIMIZE COMPILER::T3DEFUN
-         COMPILER::C2STRUCTURE-SET COMPILER::T3DEFUN-LOCAL-ENTRY)) 
+         COMPILER::C2LAMBDA-EXPR COMPILER::C2FUNCALL
+         COMPILER::INLINE-ARGS COMPILER::LINK)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
+                 COMMON-LISP::T)
              COMMON-LISP::T)
-         COMPILER::WT-SIMPLE-CALL COMPILER::GET-OUTPUT-PATHNAME)) 
+         COMPILER::T3INIT-FUN COMPILER::C2STRUCTURE-REF
+         COMPILER::WT-GLOBAL-ENTRY COMPILER::T3DEFUN-NORMAL
+         COMPILER::T3DEFUN-VARARG COMPILER::C1MAKE-VAR
+         COMPILER::C2SWITCH COMPILER::MY-CALL COMPILER::C2CALL-GLOBAL
+         COMPILER::C2CALL-UNKNOWN-GLOBAL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+                 COMMON-LISP::*)
              COMMON-LISP::T)
-         COMPILER::T3LOCAL-FUN COMPILER::T3LOCAL-DCFUN)) 
+         COMPILER::GET-OUTPUT-PATHNAME COMPILER::WT-SIMPLE-CALL)) 
+(COMMON-LISP::MAPC
+    (COMMON-LISP::LAMBDA (COMPILER::X)
+      (COMMON-LISP::SETF
+          (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE)
+          COMMON-LISP::T))
+    '(COMPILER::CMP-ANON COMMON-LISP::COMPILE COMPILER::CMP-TMP-MACRO
+         COMMON-LISP::DISASSEMBLE)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T)
+         COMPILER::MAKE-VAR COMPILER::COMPILER-COMMAND
+         COMPILER::LIST*-INLINE COMMON-LISP::COMPILE-FILE
+         COMPILER::CS-PUSH COMPILER::MAKE-INFO COMPILER::FCALLN-INLINE
+         COMPILER::C2FSET COMPILER::MAKE-TAG COMPILER::WT-CLINK
+         COMPILER::LIST-INLINE COMPILER::MAKE-FUN COMPILER::MAKE-BLK)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*)
-         COMPILER::C2PROGN COMPILER::WT-LONG-FLOAT-LOC COMPILER::C2EXPR
-         COMPILER::WT-FIXNUM-LOC COMPILER::WT-CHARACTER-LOC
-         COMPILER::C2AND COMPILER::T1EXPR COMPILER::CMP-TOPLEVEL-EVAL
-         COMPILER::WT-SHORT-FLOAT-LOC COMPILER::C2OR COMPILER::WT-LOC
-         COMPILER::CMP-EVAL COMPILER::T1EVAL-WHEN COMPILER::SET-LOC
-         COMPILER::VV-STR COMPILER::WT-TO-STRING)) 
+         COMPILER::T1EVAL-WHEN COMPILER::T1EXPR
+         COMPILER::WT-CHARACTER-LOC COMPILER::SET-LOC
+         COMPILER::CMP-TOPLEVEL-EVAL COMPILER::C2PROGN
+         COMPILER::WT-TO-STRING COMPILER::MEXPAND-DEFTYPE
+         COMPILER::WT-SHORT-FLOAT-LOC COMPILER::CMP-EVAL
+         COMPILER::WT-LOC COMPILER::C2AND COMPILER::C2EXPR
+         COMPILER::WT-LONG-FLOAT-LOC COMPILER::C2OR
+         COMPILER::WT-FIXNUM-LOC)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T)
-         COMPILER::MAKE-FUN COMPILER::MAKE-BLK
-         COMMON-LISP::COMPILE-FILE COMPILER::FCALLN-INLINE
-         COMPILER::MAKE-INFO COMPILER::CS-PUSH COMPILER::MAKE-VAR
-         COMPILER::LIST-INLINE COMPILER::C2FSET COMPILER::WT-CLINK
-         COMPILER::COMPILER-COMMAND COMPILER::MAKE-TAG
-         COMPILER::LIST*-INLINE)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
+         COMPILER::LTVP-EVAL COMPILER::FSET-FN-NAME COMPILER::C1MAPCON
+         COMPILER::FUNCTION-ARG-TYPES COMPILER::C1SHARP-COMMA
+         COMPILER::SAVE-AVMA COMPILER::C2TAGBODY-CCB COMPILER::VAR-LOC
+         COMPILER::WT-DOWN COMPILER::C1SETQ COMPILER::TAG-REF-CCB
+         COMPILER::T1DEFINE-STRUCTURE COMPILER::SAVE-FUNOB
+         COMPILER::C1VAR COMPILER::VV-STR COMPILER::C1RPLACA
+         COMPILER::INFO-SP-CHANGE COMPILER::BLK-REF-CCB
+         COMPILER::T1ORDINARY COMPILER::FIXNUM-LOC-P
+         COMPILER::FUN-REF-CCB COMPILER::C2GET COMPILER::FUN-NAME
+         COMPILER::FUN-P COMPILER::SCH-GLOBAL COMPILER::C1LET
+         COMPILER::C2TAGBODY-CLB COMPILER::C1UNWIND-PROTECT
+         COMPILER::SET-RETURN COMPILER::WT-VAR-DECL
+         COMPILER::VAR-REGISTER COMPILER::C1DEFINE-STRUCTURE
+         COMPILER::LTVP COMPILER::INLINE-POSSIBLE COMPILER::CHECK-VREF
+         COMPILER::TAG-NAME COMPILER::C2DM-RESERVE-VL
+         COMPILER::VAR-TYPE COMPILER::WT-LIST COMPILER::C1LET*
+         COMPILER::VARARG-P COMPILER::C1LOAD-TIME-VALUE
+         COMPILER::C2FUNCALL-AUX COMPILER::INFO-TYPE COMPILER::C1GET
+         COMPILER::C1NTHCDR-CONDITION COMPILER::C1AND
+         COMPILER::C1MULTIPLE-VALUE-CALL COMPILER::C1RPLACA-NTHCDR
+         COMPILER::INFO-VOLATILE COMPILER::INLINE-TYPE
+         COMPILER::LONG-FLOAT-LOC-P COMPILER::INFO-CHANGED-ARRAY
+         SYSTEM::UNDEF-COMPILER-MACRO COMPILER::DECL-BODY-SAFETY
+         COMPILER::TAG-VAR COMPILER::CHARACTER-LOC-P COMPILER::C2BIND
+         COMPILER::C1DECLARE COMPILER::CONS-TO-LISTA
+         COMPILER::C1MULTIPLE-VALUE-SETQ COMPILER::NAME-SD1
+         COMPILER::BLK-NAME COMPILER::PARSE-CVSPECS COMPILER::C1MAPL
+         COMPILER::AET-C-TYPE COMPILER::C2VAR COMPILER::COPY-INFO
+         COMPILER::C1PSETQ COMPILER::C1VREF COMPILER::FUN-REF
+         COMPILER::WT-H1 COMPILER::T1DEFCFUN COMPILER::T1PROGN
+         COMPILER::C1EVAL-WHEN COMPILER::FLAGS-POS COMPILER::WT-VS
+         COMPILER::C2VAR-KIND COMPILER::C1LENGTH
+         COMPILER::C1MULTIPLE-VALUE-BIND COMPILER::C2LOCATION
+         COMPILER::C2DM-RESERVE-V COMPILER::C2FUNCTION
+         COMPILER::WT-SWITCH-CASE COMPILER::C2TAGBODY-LOCAL
+         COMPILER::CONSTANT-FOLD-P COMPILER::NEED-TO-SET-VS-POINTERS
+         COMPILER::C1MAPCAN COMPILER::WT-FUNCALL-C COMPILER::WT-CCB-VS
+         COMPILER::C1RETURN-FROM COMPILER::GET-INCLUDED
+         COMPILER::C1BLOCK COMPILER::ADD-CONSTANT COMPILER::WT-VS-BASE
+         COMPILER::C1NTH-CONDITION COMPILER::FUN-LEVEL
+         COMPILER::UNWIND-NO-EXIT COMMON-LISP::PROCLAIM
+         COMPILER::C1PRINC COMPILER::C2EXPR* COMPILER::RESULT-TYPE
+         COMPILER::TAG-REF COMPILER::C1FUNCALL COMPILER::C1PROGN
+         COMPILER::MAXARGS COMPILER::UNDEFINED-VARIABLE COMPILER::C1THE
+         COMPILER::CMP-MACROEXPAND COMPILER::C1MAPCAR
+         COMPILER::DEFAULT-INIT COMPILER::C1STRUCTURE-SET
+         COMPILER::WT-SYMBOL-FUNCTION COMPILER::T1DEFUN
+         COMPILER::WT-DATA1 COMPILER::PUSH-DATA-INCF COMPILER::C1IF
+         COMPILER::C1NTHCDR COMPILER::ADD-SYMBOL
+         COMPILER::C1MULTIPLE-VALUE-PROG1 COMPILER::BLK-REF
+         COMPILER::WT-FUNCTION-LINK COMPILER::INFO-P COMPILER::C1FSET
+         COMPILER::C1PROGV COMPILER::C1ASSOC COMPILER::VAR-REF
+         COMPILER::ARGS-CAUSE-SIDE-EFFECT COMPILER::MDELETE-FILE
+         COMPILER::CMP-MACRO-FUNCTION COMPILER::C2DOWNWARD-FUNCTION
+         COMPILER::C2GO-LOCAL COMPILER::T1DEFLA COMPILER::VAR-REF-CCB
+         COMPILER::C1FLET COMPILER::C1LIST-NTH
+         COMPILER::ADD-LOOP-REGISTERS COMPILER::INFO-REFERRED-ARRAY
+         COMPILER::BLK-VALUE-TO-GO COMPILER::WT-VS*
+         COMPILER::NAME-TO-SD COMPILER::C1RPLACD
+         COMPILER::WT-DATA-PACKAGE-OPERATION COMPILER::C1SWITCH
+         COMPILER::C1CATCH COMPILER::WT-CAR COMPILER::C1MACROLET
+         COMPILER::OBJECT-TYPE COMPILER::C1MAPC COMPILER::T1CLINES
+         COMPILER::C1COMPILER-LET COMPILER::CMP-MACROEXPAND-1
+         COMPILER::C1TAGBODY COMPILER::C1MAPLIST COMPILER::PUSH-ARGS
+         COMPILER::T3ORDINARY COMPILER::C1MEMBER COMPILER::T1MACROLET
+         COMPILER::WT-CDR COMPILER::C1BOOLE3 COMPILER::PROCLAMATION
+         COMPILER::GET-LOCAL-RETURN-TYPE COMPILER::C1LOCAL-FUN
+         COMPILER::VAR-KIND COMPILER::WT1 COMPILER::TAG-SWITCH
+         COMPILER::C1OR COMPILER::C1STRUCTURE-REF
+         COMPILER::THE-PARAMETER COMPILER::VAR-REP-LOC
+         COMPILER::DECLARATION-TYPE COMPILER::TAG-P COMPILER::C2GETHASH
+         COMPILER::C1EXPR COMPILER::REPLACE-CONSTANT COMPILER::C1ECASE
+         COMPILER::FUN-CFUN COMPILER::SET-TOP COMPILER::TAG-LABEL
+         COMPILER::C1DM-BAD-KEY COMPILER::C1THROW COMPILER::C2GO-CCB
+         COMPILER::REP-TYPE COMPILER::C2VALUES
+         COMPILER::SHORT-FLOAT-LOC-P COMPILER::FUNCTION-RETURN-TYPE
+         COMPILER::ADD-OBJECT COMPILER::CTOP-WRITE COMPILER::C1MEMQ
+         COMPILER::WT-DOWNWARD-CLOSURE-MACRO COMPILER::C1TERPRI
+         COMPILER::T1DEFMACRO COMPILER::T3CLINES COMPILER::ADD-REG1
+         COMPILER::C1NTH COMPILER::C1ASH COMPILER::C1FMLA-CONSTANT
+         COMPILER::C2GO-CLB COMPILER::WT-CADR
+         COMPILER::C1BOOLE-CONDITION COMPILER::CLINK COMPILER::VAR-NAME
+         COMPILER::PUSH-ARGS-LISPCALL COMPILER::GET-ARG-TYPES
+         COMPILER::BLK-VAR COMPILER::C1APPLY COMPILER::CHECK-DOWNWARD
+         COMPILER::C1QUOTE COMPILER::TAG-REF-CLB
+         COMPILER::GET-LOCAL-ARG-TYPES COMPILER::REGISTER
+         COMPILER::BLK-P COMPILER::FUN-INFO COMPILER::C2RPLACD
+         COMPILER::ADD-OBJECT2 COMPILER::C2TAGBODY-BODY
+         COMPILER::T1DEFENTRY COMPILER::C1FUNCTION
+         COMPILER::C1DOWNWARD-FUNCTION COMPILER::SAFE-SYSTEM
+         COMPILER::C1GO COMPILER::BLK-EXIT COMPILER::VERIFY-DATA-VECTOR
+         COMPILER::C2RPLACA COMPILER::T2DECLARE COMPILER::MACRO-DEF-P
+         COMPILER::C1LABELS COMPILER::C1GETHASH COMPILER::FIX-OPT
+         COMPILER::SCH-LOCAL-FUN COMPILER::C1FUNOB
+         COMPILER::SET-PUSH-CATCH-FRAME COMPILER::GET-RETURN-TYPE
+         COMPILER::SET-UP-VAR-CVS COMPILER::TAG-UNWIND-EXIT
+         COMPILER::VAR-P COMPILER::C1ADD-GLOBALS COMPILER::TYPE-FILTER
+         COMPILER::WT-VV COMPILER::C1ASH-CONDITION COMPILER::VOLATILE
+         COMPILER::INLINE-BOOLE3-STRING COMPILER::C1LOCAL-CLOSURE
+         COMPILER::WRITE-BLOCK-OPEN COMPILER::ADD-ADDRESS
+         COMPILER::RESET-INFO-TYPE COMPILER::C1VALUES
+         COMPILER::BLK-REF-CLB COMPILER::C1STACK-LET)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*)
+         COMPILER::INLINE-BOOLE3)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION ((COMMON-LISP::VECTOR COMMON-LISP::T))
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807))
              COMMON-LISP::T)
-         COMPILER::COPY-ARRAY)) 
+         COMPILER::MEMOIZED-HASH-EQUAL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         COMPILER::WT-INLINE-LOC COMPILER::NCONC-FILES
+         COMPILER::COMPILER-BUILD COMPILER::C2BLOCK-LOCAL
+         COMPILER::C2DECL-BODY COMPILER::C1SYMBOL-FUN COMPILER::C2BLOCK
+         COMPILER::C1BODY COMPILER::C2RETURN-LOCAL)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
-         COMPILER::C2EXPR-TOP COMPILER::CO1SUBLIS
-         COMPILER::C2CALL-LAMBDA COMPILER::GET-INLINE-LOC
-         COMPILER::CHECK-END COMPILER::C2PSETQ COMPILER::TYPE-AND
-         COMPILER::TYPE>= COMPILER::C2MULTIPLE-VALUE-PROG1
-         COMPILER::CO1SCHAR SYSTEM::ADD-DEBUG COMPILER::C2BLOCK-CCB
-         COMPILER::C2DM-BIND-VL COMPILER::MAKE-USER-INIT
-         COMPILER::NEED-TO-PROTECT COMPILER::FAST-READ
-         COMPILER::RESULT-TYPE-FROM-ARGS COMPILER::C2BIND-INIT
-         COMPILER::JUMPS-TO-P COMPILER::C2MEMBER!2
-         COMPILER::C2CALL-LOCAL COMPILER::C2BLOCK-CLB
-         COMPILER::ARGS-INFO-CHANGED-VARS COMPILER::INLINE-PROC
-         COMPILER::C2THROW COMPILER::C1DECL-BODY
-         COMPILER::WT-MAKE-DCLOSURE COMPILER::CO1WRITE-CHAR
-         COMPILER::C1SETQ1 COMPILER::SET-JUMP-FALSE COMPILER::CO1CONS
-         COMPILER::CO1VECTOR-PUSH COMPILER::SET-VS COMPILER::SHIFT>>
-         COMPILER::COERCE-LOC-STRUCTURE-REF COMPILER::WT-FIXNUM-VALUE
-         COMPILER::C2CATCH COMPILER::C2RETURN-CCB COMPILER::MAYBE-EVAL
-         COMPILER::C2ASSOC!2 COMPILER::C2DM-BIND-INIT
-         COMPILER::C2STACK-LET COMPILER::C2LAMBDA-EXPR-WITH-KEY
-         COMPILER::ARGS-INFO-REFERRED-VARS
-         COMPILER::C2MULTIPLE-VALUE-SETQ COMPILER::C1PROGN*
-         COMPILER::WT-LONG-FLOAT-VALUE COMPILER::C2MULTIPLE-VALUE-CALL
-         COMPILER::WT-SHORT-FLOAT-VALUE COMPILER::CO1CONSTANT-FOLD
-         COMPILER::C1CONSTANT-VALUE COMPILER::C1EXPR*
-         COMPILER::CO1SPECIAL-FIX-DECL COMPILER::C2RETURN-CLB
-         COMPILER::CMPFIX-ARGS COMPILER::PROCLAIM-VAR COMPILER::C2APPLY
-         COMPILER::DO-MACRO-EXPANSION COMPILER::CFAST-WRITE
-         COMPILER::PRIN1-CMP COMPILER::SHIFT<< COMPILER::WT-REQUIREDS
-         COMPILER::C2EXPR-TOP* COMPILER::UNWIND-BDS
-         COMPILER::MULTIPLE-VALUE-CHECK COMPILER::COERCE-LOC
-         COMPILER::STRUCT-TYPE-OPT COMPILER::CO1READ-CHAR
-         COMPILER::ADD-DEBUG-INFO COMPILER::C2LIST-NTH-IMMEDIATE
-         COMPILER::WT-VAR COMPILER::C2LAMBDA-EXPR-WITHOUT-KEY
-         COMPILER::CHECK-FNAME-ARGS COMPILER::CAN-BE-REPLACED
-         COMPILER::WT-CHARACTER-VALUE COMPILER::C2UNWIND-PROTECT
-         COMPILER::SET-DBIND COMPILER::T3SHARP-COMMA
-         COMPILER::IS-REP-REFERRED COMPILER::C1FMLA
-         COMPILER::WT-V*-MACROS COMPILER::C2DM-BIND-LOC
-         COMPILER::C2BIND-LOC
-         COMPILER::COMPILER-CLEAR-COMPILER-PROPERTIES
-         COMPILER::ADD-INFO COMPILER::C2SETQ
-         COMPILER::PUSH-CHANGED-VARS COMPILER::CO1STRUCTURE-PREDICATE
-         COMPILER::SET-BDS-BIND COMPILER::SET-JUMP-TRUE
-         COMPILER::CO1READ-BYTE COMPILER::C1LAMBDA-FUN
-         COMPILER::CO1TYPEP COMPILER::CONVERT-CASE-TO-SWITCH
-         COMPILER::COMPILER-DEF-HOOK COMPILER::CO1LDB COMPILER::C1ARGS
-         COMPILER::CO1WRITE-BYTE COMPILER::CO1EQL
-         COMPILER::COMPILER-CC)) 
+         COMPILER::C1LAMBDA-EXPR COMPILER::CMPWARN COMPILER::ADD-INIT
+         COMPILER::UNWIND-EXIT COMPILER::CMPNOTE COMPILER::CMPERR
+         COMPILER::C1CASE COMPILER::WT-COMMENT COMPILER::INIT-NAME
+         COMPILER::FAST-LINK-PROCLAIMED-TYPE-P COMPILER::WT-INTEGER-LOC
+         COMPILER::WT-CVAR)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM) COMMON-LISP::T)
-         COMPILER::MLIN)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         COMPILER::C2IF COMPILER::WT-INLINE COMPILER::C2COMPILER-LET
+         COMPILER::C2FLET COMPILER::C2LABELS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
              COMMON-LISP::*)
-         COMPILER::COMPILE-FILE1)) 
+         COMPILER::C2RETURN-FROM COMPILER::C2APPLY-OPTIMIZE
+         COMPILER::C2DM COMPILER::C1DM-V COMPILER::C1DM-VL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T)
-         COMPILER::WT-DATA-BEGIN COMPILER::WT-C-PUSH COMPILER::WT-CVARS
-         COMPILER::C1T COMPILER::CVS-PUSH COMPILER::WT-DATA-FILE
-         COMPILER::ADD-LOAD-TIME-SHARP-COMMA
-         COMPILER::CLOSE-INLINE-BLOCKS COMPILER::WT-FASD-DATA-FILE
-         COMPILER::GAZONK-NAME COMPILER::WFS-ERROR
-         COMPILER::WT-NEXT-VAR-ARG COMPILER::WT-FIRST-VAR-ARG
-         COMPILER::C1NIL COMPILER::WT-DATA-END COMPILER::RESET-TOP
-         COMPILER::TAIL-RECURSION-POSSIBLE
-         COMPILER::PRINT-COMPILER-INFO COMPILER::CCB-VS-PUSH
-         COMPILER::BABOON COMPILER::INIT-ENV
-         COMPILER::PRINT-CURRENT-FORM COMPILER::VS-PUSH
-         COMPILER::INC-INLINE-BLOCKS)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::*)
+         COMPILER::T3DEFUN-AUX)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::FIXNUM)
+         (COMMON-LISP::FUNCTION
+             ((COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*)))
              COMMON-LISP::T)
-         COMPILER::MEMOIZED-HASH-EQUAL)) 
+         COMPILER::COPY-ARRAY)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T
+                 (COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*))
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807)
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807)
+                 COMMON-LISP::T)
              COMMON-LISP::FIXNUM)
-         COMPILER::PROCLAIMED-ARGD COMPILER::ANALYZE-REGS1
-         COMPILER::ANALYZE-REGS)) 
+         COMPILER::BSEARCHLEQ)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::STRING COMMON-LISP::FIXNUM
-                 COMMON-LISP::FIXNUM)
-             COMMON-LISP::T)
-         COMPILER::DASH-TO-UNDERSCORE-INT)) 
\ No newline at end of file
+             (COMMON-LISP::T
+                 (COMMON-LISP::ARRAY COMMON-LISP::T (COMMON-LISP::*))
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807)
+                 COMMON-LISP::T)
+             COMMON-LISP::FIXNUM)
+         COMPILER::PUSH-ARRAY)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM)
+         COMPILER::F-TYPE)) 
\ No newline at end of file

diff --git a/configure b/configure
index 3bab4ae5bc0ce379a8f46621ecd95d3d8012f96b..da901821dd09aaaf1a0d202f8936fa1a04b09287 100755 (executable)
--- a/configure
+++ b/configure
@@ -3980,7 +3980,7 @@ add_args_to_cflags -fsigned-char -pipe \
                    -Wno-builtin-requires-header -Wno-empty-body -Wno-self-assign \
                    -Wno-unused-but-set-variable -Wno-misleading-indentation
 
-add_args_to_ldflags -Wl,-no_pie -no-pie -Wl,-z,lazy
+add_args_to_ldflags -no-pie -Wl,-z,lazy
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for clang" >&5
 $as_echo_n "checking for clang... " >&6; }

diff --git a/configure.in b/configure.in
index 4c85b6df9ee95b58742b1ed9b37494fbdde53c14..bdb36302f0413a28f506c0afe7e23c6e6e4b13a4 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -264,7 +264,7 @@ add_args_to_cflags -fsigned-char -pipe \
                    -Wno-builtin-requires-header -Wno-empty-body -Wno-self-assign \
                    -Wno-unused-but-set-variable -Wno-misleading-indentation
 
-add_args_to_ldflags -Wl,-no_pie -no-pie -Wl,-z,lazy
+add_args_to_ldflags -no-pie -Wl,-z,lazy
 
 AC_MSG_CHECKING([for clang])
 AC_RUN_IFELSE(

diff --git a/gcl-tk/socketsl.lisp b/gcl-tk/socketsl.lisp
index 1d6a66afb4ab5e1f9f13b8396180c3d3aaa018ff..ba1d2f7cd86adca1544873a7ff8eb75586046b8f 100755 (executable)
--- a/gcl-tk/socketsl.lisp
+++ b/gcl-tk/socketsl.lisp
@@ -12,10 +12,6 @@
 (defentry our-write (int object int ) (int "our_write_object"))
 (defentry print-to-string1 (object object object) (object print_to_string1))
 
-(clines "#define reset_string_input_stream1(strm,string,start,end) reset_string_input_stream(strm,string,fix(start),fix(end))")
-(defentry reset-string-input-stream (object object object object)  (object  "reset_string_input_stream1"))
-
-
 ;(clines "#define symbol_value_any(x) ((x)->s.s_dbind)")
 ;(defentry symbol-value-any (object) (object symbol_value_any))
 

diff --git a/gcl-tk/tkl.lisp b/gcl-tk/tkl.lisp
index 3d4e78e022dfc8dbd6c5c6deb71737dd422517a6..f8fdee1babb93840d61eb8892c319d4afde10fb8 100755 (executable)
--- a/gcl-tk/tkl.lisp
+++ b/gcl-tk/tkl.lisp
@@ -293,6 +293,9 @@
    (let ()
      (send-tcl-cmd *tk-connection* tk-command nil))))
 
+(defun fsubseq (s &optional (b 0) (e (length s)))
+  (make-array (- e b) :element-type (array-element-type s) :displaced-to s :displaced-index-offset b :fill-pointer (- e b)))
+
 (defun send-tcl-cmd (c str send-and-wait )
   ;(notice-text-variables)
   (or send-and-wait (setq send-and-wait *send-and-wait*))
@@ -308,7 +311,7 @@
     
     (cond (send-and-wait
           (if *debugging*
-              (store-circle *requests* (subseq str #.(length *header*))
+              (store-circle *requests* (fsubseq str #.(length *header*))
                             msg-id))
           (store-circle *replies* nil  msg-id)
           (execute-tcl-cmd c str))
@@ -932,7 +935,7 @@
                              #.(+ 1 (length *header*))
                              3))
   (values
-   (subseq str #.(+ 4 (length *header*)))
+   (fsubseq str #.(+ 4 (length *header*)))
    (eql (aref str #.(+ 1 (length *header*))) #\0)
    reply-from
    (get-circle *requests* reply-from)))
@@ -1082,7 +1085,7 @@
             (store-circle *replies*
                           (cons success
                                 (if (eql (length tk-command) #.(+ 4 (length *header*))) ""
-                                  (subseq tk-command #.(+ 4 (length *header*)))))
+                                  (fsubseq tk-command #.(+ 4 (length *header*)))))
                           from-id))
          (#.(pos m_call *mtypes*)
             ;; Can play a game of if read-and-act called with request-id:
@@ -1114,7 +1117,7 @@
                    (var (aref *text-variable-locations* lisp-var-id))
                    (type (get var 'linked-variable-type))
                    val)
-              (setq val (coerce-result (subseq tk-command  #.(+ 3 (length *header*))) type))
+              (setq val (coerce-result (fsubseq tk-command  #.(+ 3 (length *header*))) type))
               (setf (aref *text-variable-locations* (the fixnum
                                                          ( + lisp-var-id 1)))
                     val)
@@ -1130,7 +1133,9 @@
   (let* ((s (car *string-streams*))
         (*string-streams* (cdr *string-streams*)))
     (or s (setq s (make-string-input-stream "")))
-    (si::reset-string-input-stream s string start (length string))
+    (assert (array-has-fill-pointer-p string))
+    (setf (fill-pointer string) start)
+    (si::c-set-stream-object0 s string)
     (read s nil nil)))
 
 
@@ -1196,7 +1201,7 @@
        (cond (skipping nil)
             ((eql brace-level 0)
              (if (> i beg)
-                 (setq ans (cons (subseq x beg i) ans)))
+                 (setq ans (cons (fsubseq x beg i) ans)))
              
              (setq beg (+ i 1))
                       )))
@@ -1207,12 +1212,12 @@
                   (setq beg (+ i 1))))
            (incf brace-level))
        (#\} (cond ((eql brace-level 1)
-                  (setq ans (cons (subseq x beg i) ans))
+                  (setq ans (cons (fsubseq x beg i) ans))
                   (setq skipping t)))
            (incf brace-level -1)))))
      finally
      (unless skipping
-            (setq ans (cons (subseq x beg i) ans)))
+            (setq ans (cons (fsubseq x beg i) ans)))
      (return (nreverse ans))
      ))
 
@@ -1394,7 +1399,7 @@
      (cond (start (pp v no_leading_space) (setq start nil))
           (t (pp v normal)))
      (setf x (cdr x)))
-   (subseq tk-command #.(length *header*))))
+   (fsubseq tk-command #.(length *header*))))
 
 
 
@@ -1409,7 +1414,6 @@
       (setq    gcltksrv
         (cond (host "gcltksrv")
               ((si::getenv "GCL_TK_SERVER"))
-              ((probe-file (tk-conc si::*lib-directory* "/gcl-tk/gcltksrv")))
               ((probe-file (tk-conc si::*lib-directory* "gcl-tk/gcltksrv")))
               (t (error "Must setenv GCL_TK_SERVER ")))))
   (let ((pid (if host  -1 (si::getpid)))
@@ -1427,9 +1431,9 @@
                        args
                        )))
       (print command)
-      (cond ((not host) (system command))
+      (cond ((not host) (si::system command))
            (can-rsh
-             (system (tk-conc "rsh " host " "   command
+             (si::system (tk-conc "rsh " host " "   command
                                " < /dev/null &")))
            (t (format t "Waiting for you to invoke GCL_TK_SERVER,
 on ~a as in: ~s~%" host command )))

diff --git a/h/compprotos.h b/h/compprotos.h
index 25d51badb560f1f17ad469c6f67e99eaa5d08770..2de7bbbb43a285461dcc276d76002a382d29e061 100644 (file)
--- a/h/compprotos.h
+++ b/h/compprotos.h
@@ -180,3 +180,4 @@ char *gcl_gets(char *,int);
 int gcl_puts(const char *);
 int endp_error(object);
 object Icall_gen_error_handler(object,object,object,object,ufixnum,...);
+object file_stream(object);

diff --git a/h/lu.h b/h/lu.h
index 201da4f3ea47af4bb058f07001027916d2b98041..aa8340b76303d7a3c1b7b67e953f4b209c5b1740 100644 (file)
--- a/h/lu.h
+++ b/h/lu.h
@@ -271,15 +271,14 @@ struct structure {
 
 struct stream {
   FIRSTWORD;
-  void *sm_fp;
-  object sm_object0;
-  object sm_object1;
-  int sm_int0;
-  int sm_int1;
-  char *sm_buffer;
-  char sm_mode;
-  unsigned char sm_flags;
-  short sm_fd;
+  void   *sm_fp;
+  object  sm_object0;
+  object  sm_object1;
+  char   *sm_buffer;
+  ufixnum sm_mode:4;
+  ufixnum sm_flags:6;
+  ufixnum sm_fd:6;
+  ufixnum sm_int:LM(16);
 };
 
 struct random {

diff --git a/h/object.h b/h/object.h
index 3129b67bf1613c5ab24e24c1bcafbc3664bdd057..8cde395cec7f12454f1939e06ed8125d81c979ec 100755 (executable)
--- a/h/object.h
+++ b/h/object.h
@@ -166,18 +166,18 @@ enum aelttype {                   /*  array element type  */
 /* for any stream that takes writec_char, directly (not two_way or echo)
    ie.          smm_output,smm_io, smm_string_output, smm_socket
  */
-#define STREAM_FILE_COLUMN(str) ((str)->sm.sm_int1)
+#define STREAM_FILE_COLUMN(str) ((str)->sm.sm_int)
 
 /* for smm_echo */
-#define ECHO_STREAM_N_UNREAD(strm) ((strm)->sm.sm_int0)
+#define ECHO_STREAM_N_UNREAD(strm) ((strm)->sm.sm_int)
 
 /* file fd for socket */
 #define SOCKET_STREAM_FD(strm) ((strm)->sm.sm_fd)
 #define SOCKET_STREAM_BUFFER(strm) ((strm)->sm.sm_object1)
 
 /*  for     smm_string_input  */
-#define STRING_INPUT_STREAM_NEXT(strm) ((strm)->sm.sm_int0)
-#define STRING_INPUT_STREAM_END(strm) ((strm)->sm.sm_int1)
+#define STRING_INPUT_STREAM_NEXT(strm) ((strm)->sm.sm_object0->st.st_fillp)
+#define STRING_INPUT_STREAM_END(strm) ((strm)->sm.sm_object0->st.st_dim)
 
 /* for smm_two_way and smm_echo */
 #define STREAM_OUTPUT_STREAM(strm) ((strm)->sm.sm_object1)

diff --git a/h/type.h b/h/type.h
index dd584bd6961f448e5de4fd22e9cae56c318a05a4..1e778d9b559674f25203ff88d71527ab87109067 100644 (file)
--- a/h/type.h
+++ b/h/type.h
@@ -41,7 +41,6 @@ enum smmode {                 /*  stream mode  */
        smm_output,             /*  output  */
        smm_io,                 /*  input-output  */
        smm_probe,              /*  probe  */
-       smm_file_synonym,       /*  synonym stream to file_stream  */
        smm_synonym,            /*  synonym  */
        smm_broadcast,          /*  broadcast  */
        smm_concatenated,       /*  concatenated  */
@@ -152,5 +151,4 @@ enum smmode {                       /*  stream mode  */
 #define pathname_string_symbol_streamp(a_) ({enum type _tp=type_of(a_); _tp==t_pathname || _tp == t_string\
                                                                      || _tp == t_symbol || _tp==t_stream;})
 
-#define pathname_designatorp(a_) ({object _a=(a_);enum type _tp=type_of(a_);\
-      _tp==t_pathname||_tp==t_string||(_tp==t_stream && _a->sm.sm_mode>=smm_input && _a->sm.sm_mode<=smm_file_synonym);})
+#define pathname_designatorp(a_) ({object _a=(a_);enum type _tp=type_of(a_);_tp==t_pathname||_tp==t_string||file_stream(_a)!=Cnil;})

diff --git a/lsp/gcl_directory.lsp b/lsp/gcl_directory.lsp
index 2a7142e7e647f1055d2ab964820174069d079fc3..a33a1b2b4a4b966c9f4d831d70fe0651808a36ae 100644 (file)
--- a/lsp/gcl_directory.lsp
+++ b/lsp/gcl_directory.lsp
@@ -74,4 +74,12 @@
   (let ((r (with-open-file (s (apply 'string-concatenate "|" #-winnt "which "
                                     #+winnt "for %i in (" s #+winnt ".exe) do @echo.%~$PATH:i" nil))
                           (read-line s nil 'eof))))
-    (if (eq r 'eof) s (string-downcase r))))
+    (unless (eq r 'eof)
+      (string-downcase r))))
+
+(defun get-path (s &aux
+                  (e (unless (minusp (string-match #v"([^\n\t\r ]+)([\n\t\r ]|$)" s))(match-end 1)))
+                  (w (when e (which (pathname-name (subseq s (match-beginning 1) e))))))
+  (when w
+    (string-concatenate w (subseq s e))))
+

diff --git a/lsp/gcl_iolib.lsp b/lsp/gcl_iolib.lsp
index 98df8ca08e761e6599ea6032222257cb7451f50f..4453e7227a5c34661d44c7251b1608b043059685 100755 (executable)
--- a/lsp/gcl_iolib.lsp
+++ b/lsp/gcl_iolib.lsp
@@ -69,7 +69,20 @@
           (progn ,@b)
          (close ,var)))))
 
-(defmacro with-input-from-string ((var string &key index start end) . body)
+(defun make-string-input-stream (string &optional (start 0) end)
+  (declare (optimize (safety 1)))
+  (check-type string string)
+  (check-type start seqind)
+  (check-type end (or null seqind))
+  (let ((l (- (or end (length string)) start)))
+    (make-string-input-stream-int
+     (make-array l :element-type (array-element-type string) :displaced-to string :displaced-index-offset start :fill-pointer 0)
+     0 l)))
+
+(defun get-string-input-stream-index (stream &aux (s (c-stream-object0 stream)))
+  (+ (fill-pointer s) (multiple-value-bind (a b) (array-displacement s) b)))
+
+(defmacro with-input-from-string ((var string &key index (start 0) end) . body)
   (declare (optimize (safety 1)))
   (multiple-value-bind (ds b) (find-declarations body)
     `(let ((,var (make-string-input-stream ,string ,start ,end)))
@@ -77,7 +90,8 @@
        (unwind-protect
           (multiple-value-prog1
            (progn ,@b)
-           ,@(when index `((setf ,index (get-string-input-stream-index ,var)))))
+           ,@(when index
+               `((setf ,index (get-string-input-stream-index ,var)))))
         (close ,var)))))
   
 (defmacro with-output-to-string ((var &optional string &key element-type) . body)
@@ -406,7 +420,7 @@
 
 
 (defun write-sequence (seq strm &rest r &key (start 0) end
-                          &aux (l (listp seq))(cp (eq (stream-element-type strm) 'character)))
+                          &aux (cp (eq (stream-element-type strm) 'character)))
   (declare (optimize (safety 1))(dynamic-extent r))
   (check-type seq sequence)
   (check-type strm stream)
@@ -443,9 +457,15 @@
                      if-exists iesp if-does-not-exist idnesp external-format)))
     (when (typep s 'stream) (c-set-stream-object1 s pf) s)))
 
+(defun load-pathname-exists (z)
+  (or (probe-file z)
+      (when *allow-gzipped-file*
+       (when (probe-file (string-concatenate (namestring z) ".gz"))
+         z))))
+
 (defun load-pathname (p print if-does-not-exist external-format
                        &aux (pp (merge-pathnames p))
-                       (epp (reduce (lambda (y x) (or y (probe-file (translate-pathname x "" p))))
+                       (epp (reduce (lambda (y x) (or y (load-pathname-exists (translate-pathname x "" p))))
                                     '(#P".o" #P".lsp" #P".lisp" #P"") :initial-value nil)));FIXME newest?
   (if epp
       (let* ((*load-pathname* pp)(*load-truename* epp))
@@ -484,3 +504,36 @@
       (d pd (cdr pd)))
     (values ps created)))
 
+(defun file-length (x)
+  (declare (optimize (safety 1)))
+  (check-type x (or broadcast-stream file-stream))
+  (if (typep x 'broadcast-stream)
+      (let ((s (broadcast-stream-streams x))) (if s (file-length (car (last s))) 0))
+    (multiple-value-bind (tp sz) (stat x)
+      (declare (ignore tp))
+      (/ sz (get-byte-stream-nchars x)))))
+
+(defun file-position (x &optional (pos :start pos-p))
+  (declare (optimize (safety 1)))
+  (check-type x (or broadcast-stream file-stream string-stream))
+  (check-type pos (or (member :start :end) (integer 0)))
+  (typecase x
+    (broadcast-stream
+     (let ((s (car (last (broadcast-stream-streams x)))))
+       (if s (if pos-p (file-position s pos) (file-position s)) 0)))
+    (string-stream
+     (let* ((st (c-stream-object0 x))(l (length st))(d (array-dimension st 0))
+           (p (case pos (:start 0) (:end l) (otherwise pos))))
+       (if pos-p (when (<= p d) (setf (fill-pointer st) p)) l)))
+    (otherwise
+     (let ((n (get-byte-stream-nchars x))
+          (p (case pos (:start 0) (:end (file-length x)) (otherwise pos))))
+       (if pos-p (when (fseek x (* p n)) p) (/ (ftell x) n))))))
+
+(defun file-string-length (strm obj)
+  (let* ((pos (file-position strm))
+        (w (write obj :stream strm :escape nil :readably nil))
+        (pos1 (file-position strm)));(break)
+    (declare (ignore w))
+    (file-position strm pos)
+    (- pos1 pos)))

diff --git a/lsp/gcl_namestring.lsp b/lsp/gcl_namestring.lsp
index 704b4ac356aa4bcf946b75fcc3696194a50e3217..d575f3682a4457261b966566f625241f30726a55 100644 (file)
--- a/lsp/gcl_namestring.lsp
+++ b/lsp/gcl_namestring.lsp
@@ -27,7 +27,7 @@
      (declare (optimize (safety 1)))
      (check-type x pathname-designator)
      (check-type def pathname-designator)
-     ,(labels ((new? (k &aux (f (intern (concatenate 'string "PATHNAME-" (string k)) :si)))
+     ,(labels ((new? (k &aux (f (intern (string-concatenate "PATHNAME-" (string k)) :si)))
                     `(let ((k (,f px))) (unless (equal k (,f pdef)) k))))
        `(namestring (make-pathname
          ,@(mapcan (lambda (x) (list x (new? x))) +pathname-keys+)))))

diff --git a/lsp/gcl_predlib.lsp b/lsp/gcl_predlib.lsp
index df0dbbf709eb8c3b6586be1bb15eb8096b51bfc1..791b917cf1ad60bf50c3704afbfdd48195794887 100755 (executable)
--- a/lsp/gcl_predlib.lsp
+++ b/lsp/gcl_predlib.lsp
@@ -125,6 +125,8 @@
           (character . characterp)
           (package . packagep)
           (stream . streamp)
+          (string-input-stream . string-input-stream-p)
+          (string-output-stream . string-output-stream-p)
           (file-stream . file-stream-p)
           (synonym-stream . synonym-stream-p)
           (broadcast-stream . broadcast-stream-p)

diff --git a/lsp/gcl_restart.lsp b/lsp/gcl_restart.lsp
index 139debb4be0e201d5d89a3bdd9b289f59a700277..0c9aa358723f5c433ec3c1b027a738ed228f02dc 100644 (file)
--- a/lsp/gcl_restart.lsp
+++ b/lsp/gcl_restart.lsp
@@ -73,7 +73,7 @@
                                &aux rr (report (if (stringp report) `(lambda (s) (write-string ,report s)) report)))
   (macrolet ((do-setf (x) 
                      `(when ,x 
-                        (setf (getf rr ,(intern (concatenate 'string (symbol-name x) "-FUNCTION") :keyword))
+                        (setf (getf rr ,(intern (string-concatenate (symbol-name x) "-FUNCTION") :keyword))
                               (list 'function ,x)))))
            (do-setf report)
            (do-setf interactive)

diff --git a/lsp/gcl_serror.lsp b/lsp/gcl_serror.lsp
index df4ceda4ba0a08a018e5068adafdb87785e69b9e..95f0c9ae53f310987843e17b5ef6a7eb9f3bc41d 100755 (executable)
--- a/lsp/gcl_serror.lsp
+++ b/lsp/gcl_serror.lsp
@@ -2,11 +2,11 @@
 (in-package :si)
 
 (macrolet 
- ((make-conditionp (condition &aux (n (intern (concatenate 'string (string condition) "P"))))
+ ((make-conditionp (condition &aux (n (intern (string-concatenate (string condition) "P"))))
                   `(defun ,n (x &aux (z (si-find-class ',condition)))
                      (when z
                        (funcall (setf (symbol-function ',n) (lambda (x) (typep x z))) x))))
-  (make-condition-classp (class &aux (n (intern (concatenate 'string (string class) "-CLASS-P"))))
+  (make-condition-classp (class &aux (n (intern (string-concatenate (string class) "-CLASS-P"))))
                         `(defun ,n (x &aux (s (si-find-class 'standard-class)) (z (si-find-class ',class)))
                            (when (and s z)
                              (funcall (setf (symbol-function ',n)
@@ -124,9 +124,9 @@
 
 (defun process-error (datum args &optional (default-type 'simple-error))
   (let ((internal (cond ((simple-condition-class-p datum)
-                        (find-symbol (concatenate 'string "INTERNAL-" (string datum)) :conditions))
+                        (find-symbol (string-concatenate "INTERNAL-" (string datum)) :conditions))
                        ((condition-class-p datum)
-                        (find-symbol (concatenate 'string "INTERNAL-SIMPLE-" (string datum)) :conditions)))))
+                        (find-symbol (string-concatenate "INTERNAL-SIMPLE-" (string datum)) :conditions)))))
     (coerce-to-condition (or internal datum) (if internal (list* :function-name *sig-fn-name* args) args) default-type 'process-error)))
 
 (defun universal-error-handler (n cp fn cs es &rest args &aux (*sig-fn-name* fn))

diff --git a/lsp/gcl_top.lsp b/lsp/gcl_top.lsp
index 1b61ba7117cdc3c3d8e053980335e09183b18533..a6119716a1bb8294d8a013642c3f039176592b0a 100755 (executable)
--- a/lsp/gcl_top.lsp
+++ b/lsp/gcl_top.lsp
@@ -593,12 +593,11 @@ First directory is checked for first name and all extensions etc."
        (when (eq (stat x) :directory)
          (return-from get-temp-dir x))))))
 
-(defun get-path (s &aux (m (string-match "([^ ]*)( |$)" s))(b (match-beginning 1))(e (match-end 1)))
-  (string-concatenate (which (pathname-name (subseq s b e))) (subseq s e)))
+
 
 (defvar *cc* "cc")
 (defvar *ld* "ld")
-(defvar *objdump* "objdump --source ")
+(defvar *objdump* nil)
 
 (defvar *current-directory* *system-directory*)
 
@@ -608,9 +607,9 @@ First directory is checked for first name and all extensions etc."
   (declare (fixnum i))
   (setq *current-directory* (current-directory-pathname))
   (setq *tmp-dir* (get-temp-dir)
-       *cc* (get-path *cc*)
-       *ld* (get-path *ld*)
-       *objdump* (get-path *objdump*))
+       *cc* (or (get-path *cc*) *cc*)
+       *ld* (or (get-path *ld*) *ld*)
+       *objdump* (get-path "objdump --source "))
   (dotimes (j i) (push (argv j) tem))
   (setq *command-args* (nreverse tem))
   (setq tem *lib-directory*)

diff --git a/lsp/gcl_translate_pathname.lsp b/lsp/gcl_translate_pathname.lsp
index ace0ce2e01d63e242dec90094a3a55be87f1a45c..1985b1c77985ad65973e7ab49d4f040bc19578e2 100644 (file)
--- a/lsp/gcl_translate_pathname.lsp
+++ b/lsp/gcl_translate_pathname.lsp
@@ -32,7 +32,7 @@
 (defun do-repl (x y)
   (labels ((r (x l &optional (b 0) &aux (f (string-match #v"\\*" x b)))
              (if (eql f -1) (if (eql b 0) x (subseq x b))
-               (concatenate 'string (subseq x b f) (or (car l) "") (r x (cdr l) (1+ f))))))
+               (string-concatenate (subseq x b f) (or (car l) "") (r x (cdr l) (1+ f))))))
     (r y x)))
 
 (defun dir-p (x) (when (consp x) (member (car x) '(:absolute :relative))))

diff --git a/lsp/sys-proclaim.lisp b/lsp/sys-proclaim.lisp
index 70040f4fc772aac949022b762048dea0e73dca48..21b6856963b99adfaaad1328e85f785f535cb427 100755 (executable)
--- a/lsp/sys-proclaim.lisp
+++ b/lsp/sys-proclaim.lisp
@@ -4,229 +4,269 @@
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER
-                  COMMON-LISP::*)
-              (COMMON-LISP::INTEGER -9223372036854775808
-                  9223372036854775807))
-             COMMON-LISP::FIXNUM)
-         SYSTEM::ATOI)) 
+                  COMMON-LISP::*))
+             COMMON-LISP::T)
+         SYSTEM::RESET-SYS-PATHS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             (COMMON-LISP::OR COMMON-LISP::NULL
-                 COMMON-LISP::HASH-TABLE))
-         SYSTEM::CONTEXT-HASH)) 
+             (COMMON-LISP::VECTOR COMMON-LISP::T))
+         SYSTEM::CONTEXT-VEC)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::*)
-         SYSTEM::PARSE-DEFMACRO-LAMBDA-LIST SYSTEM::PARSE-DEFMACRO)) 
+             ((COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807))
+             COMMON-LISP::T)
+         SYSTEM::PUSH-CONTEXT SYSTEM::GET-CONTEXT)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::*)
-         COMMON-LISP::SUBTYPEP COMMON-LISP::REDUCE
-         SLOOP::FIND-IN-ORDERED-LIST SYSTEM::PARSE-BODY
-         COMMON-LISP::STABLE-SORT COMMON-LISP::SORT)) 
+         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T)
+         SLOOP::PARSE-LOOP-DO ANSI-LOOP::LOOP-WHEN-IT-VARIABLE
+         SYSTEM::GET-INDEX-NODE SLOOP::LOOP-PEEK
+         ANSI-LOOP::LOOP-POP-SOURCE SYSTEM::STEP-READ-LINE
+         SYSTEM::SET-UP-TOP-LEVEL SLOOP::LOOP-POP SYSTEM::SET-ENV
+         SYSTEM::DBL COMMON-LISP::TYPE-ERROR SYSTEM::INSPECT-INDENT
+         SLOOP::PARSE-LOOP-COLLECT SYSTEM::CLEANUP
+         SYSTEM::DEFAULT-SYSTEM-BANNER
+         SYSTEM::CURRENT-DIRECTORY-PATHNAME ANSI-LOOP::LOOP-DO-WITH
+         SYSTEM::INIT-BREAK-POINTS SYSTEM::TEST-ERROR
+         SYSTEM::GET-SIG-FN-NAME SLOOP::PARSE-ONE-WHEN-CLAUSE
+         ANSI-LOOP::LOOP-DO-DO SYSTEM::READ-EVALUATED-FORM
+         SYSTEM::INSPECT-INDENT-1 ANSI-LOOP::LOOP-DO-NAMED
+         SLOOP::PARSE-LOOP-FOR SYSTEM::ALL-TRACE-DECLARATIONS
+         ANSI-LOOP::LOOP-GET-FORM ANSI-LOOP::LOOP-BIND-BLOCK
+         SLOOP::PARSE-LOOP-WHEN SYSTEM::TOP-LEVEL
+         SYSTEM::DM-TOO-FEW-ARGUMENTS SYSTEM::KCL-TOP-RESTARTS
+         SYSTEM::DEFAULT-INFO-HOTLIST SYSTEM::SHOW-RESTARTS
+         SYSTEM::DM-TOO-MANY-ARGUMENTS SYSTEM::SETUP-LINEINFO
+         SYSTEM::GET-TEMP-DIR ANSI-LOOP::LOOP-ITERATION-DRIVER
+         SLOOP::PARSE-LOOP1 SLOOP::LOOP-UN-POP
+         ANSI-LOOP::LOOP-DO-FINALLY SYSTEM::INSPECT-READ-LINE
+         ANSI-LOOP::LOOP-CONTEXT SYSTEM::SET-CURRENT
+         ANSI-LOOP::LOOP-DO-REPEAT SYSTEM::ILLEGAL-BOA
+         COMMON-LISP::LISP-IMPLEMENTATION-VERSION
+         ANSI-LOOP::LOOP-DO-RETURN ANSI-LOOP::LOOP-DO-INITIALLY
+         ANSI-LOOP::LOOP-GET-PROGN)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         SYSTEM::SHARP-+-READER SYSTEM::SHARP---READER
-         SYSTEM::SHARP-S-READER ANSI-LOOP::LOOP-GET-COLLECTION-INFO
-         SYSTEM::VERIFY-KEYWORDS SYSTEM::LIST-MERGE-SORT
-         SYSTEM::RESTART-PRINT SYSTEM::READ-INSPECT-COMMAND)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             COMMON-LISP::HASH-TABLE)
+         SYSTEM::CONTEXT-SPICE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
-             COMMON-LISP::*)
-         SYSTEM::TRACE-CALL)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             (COMMON-LISP::OR COMMON-LISP::NULL
+                 COMMON-LISP::HASH-TABLE))
+         SYSTEM::CONTEXT-HASH)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
-             COMMON-LISP::*)
-         SYSTEM::EXPAND-WILD-DIRECTORY SYSTEM::MASET)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::FIXNUM)
+         ANSI-LOOP::DUPLICATABLE-CODE-P SYSTEM::RELATIVE-LINE
+         SYSTEM::LENEL SYSTEM::GET-NODE-INDEX SYSTEM::FASLINK
+         SYSTEM::THE-END)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
-             COMMON-LISP::*)
-         SYSTEM::MME3)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::T)
+         SLOOP::IN-PACKAGE-SLOOP-MAP SLOOP::DESETQ1
+         COMMON-LISP::LOGANDC2 ANSI-LOOP::MAKE-LOOP-MINIMAX
+         COMMON-LISP::WRITE-BYTE SYSTEM::MATCH-DIMENSIONS
+         SLOOP::IN-CAREFULLY-SLOOP-FOR SLOOP::SUM-SLOOP-COLLECT
+         SYSTEM::DOT-DIR-P SLOOP::IN-FRINGE-SLOOP-MAP
+         SLOOP::COLLATE-SLOOP-COLLECT ANSI-LOOP::LOOP-TMEMBER
+         FPE::READ-OPERANDS SYSTEM::IN-INTERVAL-P SYSTEM::SUBSTRINGP
+         FPE::PAREN-READER ANSI-LOOP::HIDE-VARIABLE-REFERENCES
+         SYSTEM::QUOTATION-READER SYSTEM::ALL-MATCHES SYSTEM::GET-MATCH
+         SYSTEM::ADD-FILE ANSI-LOOP::LOOP-DO-ALWAYS SLOOP::THE-TYPE
+         SYSTEM::?PUSH SYSTEM::INCREMENT-CURSOR
+         SYSTEM::CHECK-SEQ-START-END SLOOP::MAKE-VALUE
+         SLOOP::THEREIS-SLOOP-COLLECT ANSI-LOOP::LOOP-DO-WHILE
+         COMMON-LISP::COERCE ANSI-LOOP::LOOP-TEQUAL
+         ANSI-LOOP::LOOP-DECLARE-VARIABLE COMMON-LISP::LOGNAND
+         COMMON-LISP::LOGORC1 SYSTEM::BREAK-STEP-NEXT
+         SLOOP::LOGXOR-SLOOP-COLLECT COMMON-LISP::LOGNOR
+         COMPILER::COMPILER-DEF-HOOK ANSI-LOOP::LOOP-TASSOC
+         SYSTEM::GET-LINE-OF-FORM SLOOP::MAXIMIZE-SLOOP-COLLECT
+         ANSI-LOOP::LOOP-DO-IF SYSTEM::SETF-EXPAND SYSTEM::DM-V
+         SYSTEM::ITERATE-OVER-BKPTS COMMON-LISP::NTHCDR
+         SYSTEM::CONDITION-PASS SYSTEM::DISPLAY-COMPILED-ENV
+         COMMON-LISP::LDB-TEST ANSI-LOOP::LOOP-MAYBE-BIND-FORM
+         SYSTEM::SUPER-GO SYSTEM::SETF-LOGICAL-PATHNAME-TRANSLATIONS
+         FPE::RF SYSTEM::SUB-INTERVAL-P SYSTEM::LEFT-PARENTHESIS-READER
+         COMMON-LISP::FILE-STRING-LENGTH SYSTEM::OBJLT SYSTEM::MSUB
+         SYSTEM::COERCE-TO-STRING SYSTEM::SAFE-EVAL
+         SYSTEM::SET-PATH-STREAM-NAME SYSTEM::SET-BACK
+         ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION COMMON-LISP::LOGTEST
+         SYSTEM::*BREAK-POINTS* SLOOP::=-SLOOP-FOR
+         SLOOP::MINIMIZE-SLOOP-COLLECT SYSTEM::KEYWORD-SUPPLIED-P
+         SLOOP::COUNT-SLOOP-COLLECT FPE::%-READER COMMON-LISP::LOGORC2
+         SYSTEM::SEQUENCE-CURSOR SYSTEM::LOOKUP-KEYWORD
+         COMMON-LISP::BYTE SYSTEM::PARSE-SLOT-DESCRIPTION
+         COMMON-LISP::LOGANDC1 SYSTEM::DM-NTH-CDR FPE::0-READER
+         SLOOP::L-EQUAL SYSTEM::LIST-DELQ SYSTEM::DM-NTH
+         COMMON-LISP::LDB SYSTEM::SETF-HELPER
+         SLOOP::NEVER-SLOOP-COLLECT SLOOP::PARSE-LOOP-MAP
+         COMMON-LISP::NTH SYSTEM::BREAK-STEP-INTO
+         SYSTEM::GET-INFO-CHOICES SLOOP::IN-TABLE-SLOOP-MAP
+         SYSTEM::GET-NODES COMMON-LISP::VECTOR-PUSH
+         COMMON-LISP::PATHNAME-MATCH-P SYSTEM::DBL-UP
+         ANSI-LOOP::LOOP-LOOKUP-KEYWORD FPE::READ-INSTRUCTION
+         SLOOP::ALWAYS-SLOOP-COLLECT SYSTEM::SET-DIR SYSTEM::INFO-AUX
+         SYSTEM::DISPLAY-ENV COMMON-LISP::DOCUMENTATION
+         SYSTEM::OVERWRITE-SLOT-DESCRIPTIONS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T)
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::*)
-         SYSTEM::PUSH-OPTIONAL-BINDING)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T))
-         SYSTEM::MAKE-KEYWORD)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T
-                 (COMMON-LISP::INTEGER -9223372036854775808
-                     9223372036854775807)
-                 (COMMON-LISP::INTEGER -9223372036854775808
-                     9223372036854775807)
-                 COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         SYSTEM::QUICK-SORT)) 
+         COMMON-LISP::APROPOS ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE
+         COMMON-LISP::FFLOOR SYSTEM::PRINT-DOC SYSTEM::INFO
+         SYSTEM::PARSE-BODY-HEADER COMMON-LISP::INVOKE-RESTART
+         SYSTEM::BREAK-FUNCTION SYSTEM::SHOW-INFO COMMON-LISP::FROUND
+         COMMON-LISP::GET-SETF-EXPANSION COMMON-LISP::PARSE-NAMESTRING
+         SYSTEM::APROPOS-DOC COMMON-LISP::ENSURE-DIRECTORIES-EXIST
+         COMMON-LISP::USE-VALUE COMMON-LISP::READ-FROM-STRING
+         COMMON-LISP::FTRUNCATE COMMON-LISP::STORE-VALUE
+         SYSTEM::STEPPER SYSTEM::GET-SETF-METHOD-MULTIPLE-VALUE
+         COMMON-LISP::APROPOS-LIST COMMON-LISP::FCEILING
+         COMMON-LISP::WRITE-TO-STRING
+         COMMON-LISP::DECODE-UNIVERSAL-TIME)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T
-                 (COMMON-LISP::INTEGER -9223372036854775808
-                     9223372036854775807)
-                 COMMON-LISP::T COMMON-LISP::T)
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         SYSTEM::BIGNTHCDR)) 
+         SYSTEM::SETF-EXPAND-1 SLOOP::LOOP-PARSE-ADDITIONAL-COLLECTIONS
+         SYSTEM::WARN-VERSION ANSI-LOOP::LOOP-TRANSLATE
+         ANSI-LOOP::LOOP-FOR-IN ANSI-LOOP::PRINT-LOOP-UNIVERSE
+         ANSI-LOOP::LOOP-STANDARD-EXPANSION
+         ANSI-LOOP::LOOP-ANSI-FOR-EQUALS SYSTEM::DM-VL
+         SYSTEM::SHARP-A-READER COMMON-LISP::DEPOSIT-FIELD
+         SYSTEM::RESTART-CASE-EXPRESSION-CONDITION
+         SYSTEM::APPLY-DISPLAY-FUN ANSI-LOOP::HIDE-VARIABLE-REFERENCE
+         SYSTEM::FLOATING-POINT-ERROR SYSTEM::GET-SLOT-POS
+         ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE
+         SYSTEM::MAKE-BREAK-POINT SYSTEM::SHARP-V-READER
+         SYSTEM::TO-REGEXP-OR-NAMESTRING ANSI-LOOP::LOOP-FOR-ON
+         SYSTEM::SHARP-U-READER ANSI-LOOP::LOOP-SUM-COLLECTION
+         SYSTEM::SHARP-P-READER SYSTEM::MAKE-T-TYPE
+         ANSI-LOOP::LOOP-FOR-ACROSS SYSTEM::MFR SYSTEM::RECURSE-DIR
+         SYSTEM::PATHNAME-PARSE ANSI-LOOP::LOOP-FOR-BEING
+         COMMON-LISP::DPB SYSTEM::SHARP-DQ-READER
+         SYSTEM::CHECK-TRACE-ARGS SYSTEM::DEFMACRO*
+         SYSTEM::CHECK-S-DATA FPE::REF)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
-         COMMON-LISP::EVERY COMMON-LISP::SET-DIFFERENCE
-         SYSTEM::VECTOR-PUSH-STRING SYSTEM::PROCESS-ERROR
-         COMMON-LISP::POSITION-IF-NOT COMMON-LISP::FIND-IF
-         SLOOP::LOOP-ADD-BINDING COMMON-LISP::BIT-ORC1
-         COMMON-LISP::READ-SEQUENCE SYSTEM::INTERNAL-COUNT-IF
-         COMMON-LISP::COUNT COMMON-LISP::MISMATCH
-         COMMON-LISP::ADJUST-ARRAY COMMON-LISP::INTERSECTION
-         COMMON-LISP::UNION COMMON-LISP::DELETE-IF-NOT
-         COMMON-LISP::NINTERSECTION COMMON-LISP::BIT-ANDC1
-         COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::TYPEP
-         COMMON-LISP::NUNION COMMON-LISP::WRITE-SEQUENCE
-         COMMON-LISP::VECTOR-PUSH-EXTEND COMMON-LISP::REMOVE
-         COMMON-LISP::BIT-IOR SLOOP::PARSE-LOOP-MACRO
-         COMMON-LISP::SEARCH COMMON-LISP::SUBSETP
-         COMMON-LISP::SET-EXCLUSIVE-OR SYSTEM::WREADDIR
-         COMMON-LISP::POSITION-IF COMMON-LISP::DELETE
-         COMMON-LISP::BIT-EQV COMMON-LISP::BIT-ANDC2
-         COMMON-LISP::BIT-AND COMMON-LISP::NSET-EXCLUSIVE-OR
-         SLOOP::IN-ARRAY-SLOOP-FOR ANSI-LOOP::LOOP-CHECK-DATA-TYPE
-         COMMON-LISP::POSITION COMMON-LISP::MAKE-SEQUENCE
-         COMMON-LISP::NOTEVERY COMMON-LISP::MAP-INTO
-         COMMON-LISP::REPLACE COMMON-LISP::NSET-DIFFERENCE
+         SYSTEM::FIND-IHS COMMON-LISP::NSET-DIFFERENCE
+         COMMON-LISP::BIT-NAND SYSTEM::BREAK-CALL
+         COMMON-LISP::COUNT-IF-NOT COMMON-LISP::DELETE
+         SYSTEM::INTERNAL-COUNT COMMON-LISP::BIT-ORC1
+         COMMON-LISP::DELETE-IF COMMON-LISP::BIT-ANDC1
+         SYSTEM::VECTOR-PUSH-STRING COMMON-LISP::MISMATCH
+         COMMON-LISP::NOTEVERY SYSTEM::PROCESS-ERROR COMMON-LISP::TYPEP
+         COMMON-LISP::BIT-IOR COMMON-LISP::BIT-EQV
+         COMMON-LISP::COUNT-IF COMMON-LISP::REMOVE-IF
+         COMMON-LISP::EVERY COMMON-LISP::POSITION-IF-NOT
+         COMMON-LISP::ADJUST-ARRAY COMMON-LISP::VECTOR-PUSH-EXTEND
+         SYSTEM::INTERNAL-COUNT-IF-NOT COMMON-LISP::COUNT
+         COMMON-LISP::DELETE-IF-NOT COMMON-LISP::NINTERSECTION
          COMMON-LISP::FIND-IF-NOT COMMON-LISP::BIT-ORC2
-         COMMON-LISP::DELETE-IF COMMON-LISP::CERROR
-         COMMON-LISP::BIT-XOR COMMON-LISP::FIND COMMON-LISP::FILL
-         SYSTEM::INTERNAL-COUNT-IF-NOT COMMON-LISP::REMOVE-IF
-         COMMON-LISP::BIT-NAND COMMON-LISP::BIT-NOR COMMON-LISP::SOME
-         COMMON-LISP::COUNT-IF SYSTEM::BREAK-CALL
-         COMMON-LISP::COUNT-IF-NOT SYSTEM::FIND-IHS COMMON-LISP::NOTANY
-         SYSTEM::INTERNAL-COUNT)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         SYSTEM::PATHNAME-PARSE ANSI-LOOP::LOOP-TRANSLATE
-         SYSTEM::CHECK-S-DATA SYSTEM::MFR FPE::REF
-         ANSI-LOOP::LOOP-STANDARD-EXPANSION ANSI-LOOP::LOOP-FOR-ON
-         ANSI-LOOP::LOOP-SUM-COLLECTION SYSTEM::SHARP-DQ-READER
-         COMMON-LISP::DPB SYSTEM::CHECK-TRACE-ARGS
-         SLOOP::LOOP-PARSE-ADDITIONAL-COLLECTIONS SYSTEM::RECURSE-DIR
-         SYSTEM::SHARP-U-READER SYSTEM::FLOATING-POINT-ERROR
-         ANSI-LOOP::LOOP-FOR-IN ANSI-LOOP::HIDE-VARIABLE-REFERENCE
-         SYSTEM::GET-SLOT-POS SYSTEM::APPLY-DISPLAY-FUN
-         SYSTEM::RESTART-CASE-EXPRESSION-CONDITION
-         SYSTEM::MAKE-BREAK-POINT SYSTEM::TO-REGEXP-OR-NAMESTRING
-         COMMON-LISP::DEPOSIT-FIELD SYSTEM::SHARP-V-READER
-         SYSTEM::MAKE-T-TYPE ANSI-LOOP::LOOP-FOR-ACROSS
-         ANSI-LOOP::LOOP-ANSI-FOR-EQUALS ANSI-LOOP::PRINT-LOOP-UNIVERSE
-         ANSI-LOOP::LOOP-FOR-BEING SYSTEM::SHARP-P-READER SYSTEM::DM-VL
-         SYSTEM::SHARP-A-READER ANSI-LOOP::LOOP-MAKE-ITERATION-VARIABLE
-         SYSTEM::DEFMACRO* SYSTEM::SETF-EXPAND-1 SYSTEM::WARN-VERSION)) 
+         COMMON-LISP::SUBSETP COMMON-LISP::SOME SYSTEM::WREADDIR
+         COMMON-LISP::SET-DIFFERENCE COMMON-LISP::UNION
+         COMMON-LISP::BIT-XOR SLOOP::PARSE-LOOP-MACRO
+         COMMON-LISP::REPLACE COMMON-LISP::REMOVE
+         SLOOP::LOOP-ADD-BINDING COMMON-LISP::BIT-ANDC2
+         COMMON-LISP::READ-SEQUENCE COMMON-LISP::CERROR
+         COMMON-LISP::INTERSECTION COMMON-LISP::POSITION-IF
+         ANSI-LOOP::LOOP-CHECK-DATA-TYPE SYSTEM::INTERNAL-COUNT-IF
+         COMMON-LISP::NUNION COMMON-LISP::WRITE-SEQUENCE
+         COMMON-LISP::MAP-INTO COMMON-LISP::MAKE-SEQUENCE
+         COMMON-LISP::SET-EXCLUSIVE-OR SLOOP::IN-ARRAY-SLOOP-FOR
+         COMMON-LISP::FIND-IF COMMON-LISP::SEARCH COMMON-LISP::FILL
+         COMMON-LISP::FIND COMMON-LISP::NOTANY
+         COMMON-LISP::NSET-EXCLUSIVE-OR COMMON-LISP::BIT-NOR
+         COMMON-LISP::REMOVE-IF-NOT COMMON-LISP::POSITION
+         COMMON-LISP::BIT-AND)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
+                 COMMON-LISP::T)
              COMMON-LISP::T)
-         SYSTEM::MME2 COMMON-LISP::NSUBSTITUTE SYSTEM::MATCH-COMPONENT
-         SYSTEM::COMPLETE-PROP SYSTEM::WALK-DIR
-         COMMON-LISP::TRANSLATE-PATHNAME ANSI-LOOP::ADD-LOOP-PATH
-         SYSTEM::DIR-PARSE ANSI-LOOP::LOOP-MAKE-VARIABLE
-         COMMON-LISP::SUBSTITUTE-IF COMMON-LISP::NSUBSTITUTE-IF
-         SYSTEM::PUSH-LET-BINDING COMMON-LISP::SUBSTITUTE
-         ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH COMMON-LISP::MAP
-         COMMON-LISP::SUBSTITUTE-IF-NOT COMMON-LISP::NSUBSTITUTE-IF-NOT
-         ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH
-         SLOOP::LOOP-DECLARE-BINDING
-         ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH
-         SYSTEM::CHECK-TYPE-SYMBOL)) 
+         SYSTEM::FIND-LINE-IN-FUN ANSI-LOOP::LOOP-FOR-ARITHMETIC
+         SYSTEM::EXPAND-RANGE SYSTEM::MAYBE-BREAK SYSTEM::MINMAX
+         SLOOP::FIRST-USE-SLOOP-FOR SLOOP::FIRST-SLOOP-FOR
+         SYSTEM::SETF-STRUCTURE-ACCESS SYSTEM::DO-BREAK-LEVEL
+         SYSTEM::CALL-TEST SYSTEM::ELEMENT SYSTEM::LOAD-PATHNAME
+         SYSTEM::COERCE-TO-CONDITION SYSTEM::ELSUB)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T
-                 (COMMON-LISP::INTEGER -9223372036854775808
-                     9223372036854775807))
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
-         SYSTEM::SHARP-EQ-READER SYSTEM::SHARP-SHARP-READER)) 
+         SLOOP::DEF-LOOP-INTERNAL COMMON-LISP::MERGE
+         SYSTEM::PRINT-STACK-FRAME)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::*)
              COMMON-LISP::T)
-         SYSTEM::ELSUB SLOOP::FIRST-USE-SLOOP-FOR
-         SLOOP::FIRST-SLOOP-FOR SYSTEM::SETF-STRUCTURE-ACCESS
-         SYSTEM::FIND-LINE-IN-FUN SYSTEM::COERCE-TO-CONDITION
-         ANSI-LOOP::LOOP-FOR-ARITHMETIC SYSTEM::MAYBE-BREAK
-         SYSTEM::ELEMENT SYSTEM::DO-BREAK-LEVEL SYSTEM::CALL-TEST)) 
+         COMMON-LISP::ENCODE-UNIVERSAL-TIME)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
+                 COMMON-LISP::*)
              COMMON-LISP::T)
-         ANSI-LOOP::LOOP-SEQUENCER)) 
+         ANSI-LOOP::LOOP-PACKAGE-SYMBOLS-ITERATION-PATH
+         SYSTEM::COMPLETE-PROP SYSTEM::CHECK-TYPE-SYMBOL
+         COMMON-LISP::NSUBSTITUTE
+         ANSI-LOOP::LOOP-SEQUENCE-ELEMENTS-PATH COMMON-LISP::SUBSTITUTE
+         COMMON-LISP::TRANSLATE-PATHNAME COMMON-LISP::NSUBSTITUTE-IF
+         COMMON-LISP::MAP SLOOP::LOOP-DECLARE-BINDING SYSTEM::WALK-DIR
+         SYSTEM::MATCH-COMPONENT ANSI-LOOP::LOOP-MAKE-VARIABLE
+         ANSI-LOOP::ADD-LOOP-PATH COMMON-LISP::SUBSTITUTE-IF
+         COMMON-LISP::NSUBSTITUTE-IF-NOT SYSTEM::MME2
+         ANSI-LOOP::LOOP-HASH-TABLE-ITERATION-PATH
+         COMMON-LISP::SUBSTITUTE-IF-NOT SYSTEM::PUSH-LET-BINDING)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T)
+             (COMMON-LISP::T COMMON-LISP::T
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807))
              COMMON-LISP::T)
-         SYSTEM::MAKE-CONSTRUCTOR SYSTEM::MAKE-PREDICATE)) 
+         SYSTEM::SHARP-SHARP-READER SYSTEM::SHARP-EQ-READER)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
                  COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         SYSTEM::PUSH-SUB-LIST-BINDING SYSTEM::DO-ARG-COUNT-ERROR)) 
+         SYSTEM::DO-ARG-COUNT-ERROR SYSTEM::PUSH-SUB-LIST-BINDING)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::*)
+                 COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         SLOOP::DEF-LOOP-INTERNAL COMMON-LISP::MERGE
-         SYSTEM::PRINT-STACK-FRAME)) 
+         SYSTEM::MAKE-CONSTRUCTOR SYSTEM::MAKE-PREDICATE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
                  COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
              COMMON-LISP::T)
-         COMMON-LISP::ENCODE-UNIVERSAL-TIME)) 
+         ANSI-LOOP::LOOP-SEQUENCER)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
@@ -234,43 +274,50 @@
                  COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
          SYSTEM::UNIVERSAL-ERROR-HANDLER)) 
+(COMMON-LISP::MAPC
+    (COMMON-LISP::LAMBDA (COMPILER::X)
+      (COMMON-LISP::SETF
+          (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE)
+          COMMON-LISP::T))
+    '(SYSTEM::SI-FIND-CLASS SYSTEM::WARNINGP SYSTEM::SI-CLASS-OF
+         SYSTEM::CONDITION-CLASS-P SYSTEM::UNTRACE-ONE
+         SYSTEM::MAKE-ACCESS-FUNCTION SYSTEM::SIMPLE-CONDITION-CLASS-P
+         SYSTEM::CONDITIONP SYSTEM::AUTOLOAD
+         SYSTEM::SI-CLASS-PRECEDENCE-LIST SYSTEM::SI-CLASSP
+         FPE::BREAK-ON-FLOATING-POINT-EXCEPTIONS SYSTEM::TRACE-ONE
+         SYSTEM::AUTOLOAD-MACRO SYSTEM::DEFINE-STRUCTURE
+         SYSTEM::SI-CLASS-NAME)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::T)
-         COMMON-LISP::MERGE-PATHNAMES
-         COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME ANSI-LOOP::LOOP-ERROR
-         COMMON-LISP::WILD-PATHNAME-P SLOOP::LOOP-ADD-TEMPS
-         SYSTEM::FILE-SEARCH SYSTEM::INFO-SEARCH
-         COMMON-LISP::PATHNAME-VERSION COMMON-LISP::WARN SYSTEM::MGSUB
-         COMMON-LISP::ARRAY-ROW-MAJOR-INDEX
-         COMMON-LISP::REMOVE-DUPLICATES COMMON-LISP::PATHNAME-NAME
-         COMMON-LISP::BIT COMMON-LISP::FIND-RESTART SYSTEM::TO-REGEXP
-         SYSTEM::PROCESS-SOME-ARGS COMMON-LISP::ERROR
-         COMMON-LISP::REQUIRE COMMON-LISP::OPEN
-         COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE SLOOP::ADD-FROM-DATA
-         SYSTEM::BREAK-LEVEL SYSTEM::LIST-MATCHES
-         COMMON-LISP::DELETE-DUPLICATES ANSI-LOOP::LOOP-WARN
-         COMMON-LISP::PATHNAME-DEVICE COMMON-LISP::LOAD
-         COMMON-LISP::PATHNAME-HOST COMMON-LISP::SBIT SYSTEM::NLOAD
-         COMMON-LISP::BIT-NOT COMMON-LISP::ENOUGH-NAMESTRING
-         COMMON-LISP::SIGNAL COMMON-LISP::ARRAY-IN-BOUNDS-P
-         COMMON-LISP::PATHNAME-TYPE SYSTEM::FILE-TO-STRING
-         SYSTEM::LOGICAL-PATHNAME-PARSE SYSTEM::NTH-STACK-FRAME
-         ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES SYSTEM::MGLIST
-         COMMON-LISP::DIRECTORY SYSTEM::BAD-SEQ-LIMIT
-         COMMON-LISP::PATHNAME-DIRECTORY COMMON-LISP::READ-BYTE
-         SYSTEM::LINK-EXPAND COMMON-LISP::CONCATENATE
-         COMMON-LISP::MAKE-ARRAY)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*)
+         SYSTEM::INSTREAM-NAME ANSI-LOOP::LOOP-LIST-STEP
+         COMMON-LISP::PRIN1-TO-STRING ANSI-LOOP::NAMED-VARIABLE
+         SYSTEM::WAITING SYSTEM::FIND-DECLARATIONS COMMON-LISP::INSPECT
+         SYSTEM::END-WAITING SYSTEM::BREAK-GO SYSTEM::INFO-SUBFILE
+         COMMON-LISP::INVOKE-RESTART-INTERACTIVELY
+         ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES SYSTEM::INSPECT-OBJECT
+         SYSTEM::BREAK-LEVEL-INVOKE-RESTART SYSTEM::EXPAND-RANGES
+         SYSTEM::GET-&ENVIRONMENT COMMON-LISP::DESCRIBE
+         COMMON-LISP::PRINC-TO-STRING)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         SYSTEM::NEWLINE SYSTEM::LIST-TOGGLE-CASE
-         COMMON-LISP::RENAME-FILE ANSI-LOOP::ESTIMATE-CODE-SIZE
-         SYSTEM::SOURCE-PORTION SYSTEM::RESTART-REPORT SYSTEM::DO-REPL
-         SYSTEM::FIND-DOC ANSI-LOOP::ESTIMATE-CODE-SIZE-1
-         SYSTEM::NEW-SEMI-COLON-READER)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T)
+         COMMON-LISP::ABORT ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE
+         SYSTEM::MAKE-S-DATA ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL
+         ANSI-LOOP::MAKE-LOOP-PATH SYSTEM::CURRENT-STEP-FUN SYSTEM::LOC
+         SYSTEM::DBL-READ SYSTEM::MAKE-RESTART
+         SYSTEM::TRANSFORM-KEYWORDS COMMON-LISP::Y-OR-N-P
+         SYSTEM::NEXT-MATCH COMMON-LISP::COMPUTE-RESTARTS
+         SLOOP::PARSE-LOOP-WITH COMMON-LISP::VECTOR SYSTEM::STEP-NEXT
+         ANSI-LOOP::MAKE-LOOP-COLLECTOR
+         COMMON-LISP::USER-HOMEDIR-PATHNAME SLOOP::PARSE-LOOP-DECLARE
+         COMMON-LISP::YES-OR-NO-P SYSTEM::STEP-INTO
+         SYSTEM::MAKE-CONTEXT SYSTEM::BREAK-LOCALS
+         SYSTEM::DESCRIBE-ENVIRONMENT COMMON-LISP::DRIBBLE
+         ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL SYSTEM::MAYBE-CLEAR-INPUT
+         COMMON-LISP::BREAK ANSI-LOOP::LOOP-GENTEMP
+         ANSI-LOOP::MAKE-LOOP-UNIVERSE SYSTEM::MAKE-INSTREAM
+         COMMON-LISP::MAKE-PATHNAME)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
@@ -278,74 +325,6 @@
                   9223372036854775807))
              COMMON-LISP::FIXNUM)
          FPE::FE-ENABLE SYSTEM::DBL-WHAT-FRAME)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::*)
-         SYSTEM::INFO SYSTEM::GET-SETF-METHOD-MULTIPLE-VALUE
-         COMMON-LISP::FTRUNCATE COMMON-LISP::USE-VALUE
-         COMMON-LISP::INVOKE-RESTART COMMON-LISP::WRITE-TO-STRING
-         COMMON-LISP::FCEILING COMMON-LISP::FROUND
-         COMMON-LISP::READ-FROM-STRING COMMON-LISP::FFLOOR
-         SYSTEM::PARSE-BODY-HEADER SYSTEM::BREAK-FUNCTION
-         SYSTEM::APROPOS-DOC COMMON-LISP::APROPOS
-         COMMON-LISP::APROPOS-LIST
-         ANSI-LOOP::LOOP-CONSTANT-FOLD-IF-POSSIBLE
-         COMMON-LISP::GET-SETF-EXPANSION SYSTEM::PRINT-DOC
-         COMMON-LISP::PARSE-NAMESTRING
-         COMMON-LISP::ENSURE-DIRECTORIES-EXIST
-         COMMON-LISP::DECODE-UNIVERSAL-TIME SYSTEM::SHOW-INFO
-         COMMON-LISP::STORE-VALUE SYSTEM::STEPPER)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         COMMON-LISP::VECTOR-PUSH SYSTEM::DM-NTH COMMON-LISP::LOGORC1
-         SLOOP::L-EQUAL SLOOP::NEVER-SLOOP-COLLECT
-         COMMON-LISP::LDB-TEST COMMON-LISP::LDB COMMON-LISP::LOGORC2
-         SLOOP::COUNT-SLOOP-COLLECT SLOOP::MAXIMIZE-SLOOP-COLLECT
-         SYSTEM::ALL-MATCHES ANSI-LOOP::LOOP-TMEMBER SLOOP::THE-TYPE
-         SYSTEM::?PUSH SYSTEM::INCREMENT-CURSOR SYSTEM::SET-DIR
-         SYSTEM::DM-NTH-CDR SYSTEM::IN-INTERVAL-P SLOOP::MAKE-VALUE
-         SYSTEM::DBL-UP COMMON-LISP::COERCE SYSTEM::MATCH-DIMENSIONS
-         COMMON-LISP::LOGNAND SLOOP::=-SLOOP-FOR
-         SYSTEM::KEYWORD-SUPPLIED-P SYSTEM::OVERWRITE-SLOT-DESCRIPTIONS
-         SYSTEM::LEFT-PARENTHESIS-READER
-         ANSI-LOOP::LOOP-MAYBE-BIND-FORM SYSTEM::COERCE-TO-STRING
-         SYSTEM::ADD-FILE SLOOP::PARSE-LOOP-MAP COMMON-LISP::LOGNOR
-         SYSTEM::MSUB SYSTEM::SET-BACK SYSTEM::SUPER-GO
-         SYSTEM::SUBSTRINGP ANSI-LOOP::LOOP-TEQUAL
-         ANSI-LOOP::LOOP-DO-WHILE SYSTEM::GET-LINE-OF-FORM
-         FPE::READ-INSTRUCTION SYSTEM::SUB-INTERVAL-P
-         SYSTEM::CHECK-SEQ-START-END SYSTEM::*BREAK-POINTS*
-         ANSI-LOOP::MAKE-LOOP-MINIMAX SLOOP::IN-PACKAGE-SLOOP-MAP
-         SYSTEM::DM-V SYSTEM::INFO-AUX
-         ANSI-LOOP::HIDE-VARIABLE-REFERENCES
-         SLOOP::COLLATE-SLOOP-COLLECT COMMON-LISP::PATHNAME-MATCH-P
-         SYSTEM::SET-PATH-STREAM-NAME SLOOP::SUM-SLOOP-COLLECT
-         ANSI-LOOP::LOOP-LOOKUP-KEYWORD
-         ANSI-LOOP::LOOP-DECLARE-VARIABLE SYSTEM::BREAK-STEP-NEXT
-         FPE::RF SLOOP::IN-TABLE-SLOOP-MAP SYSTEM::OBJLT
-         FPE::READ-OPERANDS SYSTEM::BREAK-STEP-INTO COMMON-LISP::BYTE
-         SYSTEM::SEQUENCE-CURSOR SYSTEM::LIST-DELQ
-         SYSTEM::SETF-LOGICAL-PATHNAME-TRANSLATIONS
-         SYSTEM::CONDITION-PASS SYSTEM::SETF-HELPER FPE::0-READER
-         SYSTEM::DISPLAY-COMPILED-ENV COMMON-LISP::NTH
-         COMPILER::COMPILER-DEF-HOOK SYSTEM::DOT-DIR-P
-         COMMON-LISP::LOGTEST SYSTEM::QUOTATION-READER
-         SYSTEM::ITERATE-OVER-BKPTS COMMON-LISP::LOGANDC1
-         SLOOP::ALWAYS-SLOOP-COLLECT SLOOP::DESETQ1
-         SYSTEM::GET-INFO-CHOICES COMMON-LISP::WRITE-BYTE
-         ANSI-LOOP::LOOP-DO-IF ANSI-LOOP::LOOP-NOTE-MINIMAX-OPERATION
-         ANSI-LOOP::LOOP-TASSOC SLOOP::IN-CAREFULLY-SLOOP-FOR
-         COMMON-LISP::DOCUMENTATION FPE::PAREN-READER SYSTEM::GET-NODES
-         SYSTEM::PARSE-SLOT-DESCRIPTION SLOOP::IN-FRINGE-SLOOP-MAP
-         SYSTEM::SAFE-EVAL SYSTEM::DISPLAY-ENV FPE::%-READER
-         SLOOP::THEREIS-SLOOP-COLLECT SYSTEM::LOOKUP-KEYWORD
-         COMMON-LISP::LOGANDC2 COMMON-LISP::NTHCDR
-         SLOOP::MINIMIZE-SLOOP-COLLECT SYSTEM::GET-MATCH
-         SYSTEM::SETF-EXPAND SLOOP::LOGXOR-SLOOP-COLLECT
-         ANSI-LOOP::LOOP-DO-ALWAYS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
@@ -357,263 +336,300 @@
          SYSTEM::ROUND-UP)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T)
-         COMMON-LISP::Y-OR-N-P COMMON-LISP::YES-OR-NO-P
-         COMMON-LISP::DRIBBLE COMMON-LISP::VECTOR SYSTEM::NEXT-MATCH
-         SYSTEM::MAKE-S-DATA SYSTEM::LOC SYSTEM::BREAK-LOCALS
-         SLOOP::PARSE-LOOP-WITH COMMON-LISP::USER-HOMEDIR-PATHNAME
-         SYSTEM::STEP-INTO SYSTEM::MAYBE-CLEAR-INPUT
-         ANSI-LOOP::MAKE-LOOP-PATH SYSTEM::STEP-NEXT
-         ANSI-LOOP::LOOP-GENTEMP COMMON-LISP::COMPUTE-RESTARTS
-         SYSTEM::CURRENT-STEP-FUN SYSTEM::MAKE-INSTREAM
-         ANSI-LOOP::MAKE-LOOP-COLLECTOR SYSTEM::MAKE-RESTART
-         SYSTEM::DESCRIBE-ENVIRONMENT SYSTEM::TRANSFORM-KEYWORDS
-         COMMON-LISP::ABORT ANSI-LOOP::MAKE-STANDARD-LOOP-UNIVERSE
-         ANSI-LOOP::MAKE-LOOP-UNIVERSE SLOOP::PARSE-LOOP-DECLARE
-         COMMON-LISP::BREAK ANSI-LOOP::LOOP-DISALLOW-CONDITIONAL
-         SYSTEM::MAKE-CONTEXT SYSTEM::DBL-READ
-         COMMON-LISP::MAKE-PATHNAME
-         ANSI-LOOP::MAKE-LOOP-MINIMAX-INTERNAL)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*)
-         ANSI-LOOP::LOOP-OPTIMIZATION-QUANTITIES SYSTEM::BREAK-GO
-         COMMON-LISP::FILE-AUTHOR SYSTEM::ENSURE-DIR-STRING
-         SYSTEM::INFO-SUBFILE COMMON-LISP::DESCRIBE SYSTEM::END-WAITING
-         COMMON-LISP::PRIN1-TO-STRING SYSTEM::FIND-DECLARATIONS
-         COMMON-LISP::INSPECT ANSI-LOOP::NAMED-VARIABLE
-         SYSTEM::GET-&ENVIRONMENT SYSTEM::INSPECT-OBJECT
-         COMMON-LISP::PRINC-TO-STRING ANSI-LOOP::LOOP-LIST-STEP
-         SYSTEM::INSTREAM-NAME SYSTEM::BREAK-LEVEL-INVOKE-RESTART
-         SYSTEM::WAITING COMMON-LISP::INVOKE-RESTART-INTERACTIVELY)) 
+         (COMMON-LISP::FUNCTION
+             ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER
+                  COMMON-LISP::*)
+              (COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807))
+             COMMON-LISP::FIXNUM)
+         SYSTEM::ATOI)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
-         SYSTEM::IHS-NOT-INTERPRETED-ENV COMMON-LISP::NINTH
-         SYSTEM::FIND-KCL-TOP-RESTART COMMON-LISP::TRUENAME
-         SYSTEM::DIRECTORY-LIST-CHECK SYSTEM::REAL-ASINH
-         SYSTEM::SHOW-ENVIRONMENT SYSTEM::PRINT-FRS
-         SYSTEM::REWRITE-RESTART-CASE-CLAUSE
-         COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM
-         ANSI-LOOP::LOOP-COLLECTOR-DATA SLOOP::POINTER-FOR-COLLECT
-         SYSTEM::MLP SYSTEM::WILD-PATH-ELEMENT-P SYSTEM::LNP
-         ANSI-LOOP::LOOP-MINIMAX-OPERATIONS SYSTEM::FRS-KIND
-         SYSTEM::BKPT-FILE COMMON-LISP::FIFTH
-         ANSI-LOOP::LOOP-COLLECTOR-P ANSI-LOOP::LOOP-UNIVERSE-ANSI
-         ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS SYSTEM::IDESCRIBE
-         ANSI-LOOP::LOOP-CONSTANTP
-         ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS COMMON-LISP::PROBE-FILE
-         ANSI-LOOP::LOOP-UNIVERSE-P COMMON-LISP::SINH SYSTEM::RESTART-P
-         SYSTEM::S-DATA-DOCUMENTATION
+         SYSTEM::REGEXP-CONV SYSTEM::DIR-CONJ SYSTEM::DIR-P
+         ANSI-LOOP::LOOP-LIST-COLLECTION COMMON-LISP::COSH
+         SYSTEM::GET-BYTE-STREAM-NCHARS SYSTEM::INSPECT-CONS
+         SYSTEM::KNOWN-TYPE-P SYSTEM::LNP COMMON-LISP::SEVENTH
+         SYSTEM::BKPT-FUNCTION SYSTEM::WILD-DIR-ELEMENT-P
+         COMMON-LISP::COMPILER-MACRO-FUNCTION
+         ANSI-LOOP::LOOP-HACK-ITERATION
          COMMON-LISP::ECHO-STREAM-OUTPUT-STREAM
-         SYSTEM::FIND-DOCUMENTATION SYSTEM::INFO-GET-FILE
-         SLOOP::PARSE-NO-BODY COMMON-LISP::FILE-NAMESTRING
-         COMMON-LISP::COMPILER-MACRO-FUNCTION SYSTEM::PROCESS-ARGS
-         ANSI-LOOP::LOOP-COLLECTOR-DTYPE COMMON-LISP::PHASE
-         SYSTEM::MAKE-FRAME SYSTEM::INSTREAM-STREAM
-         ANSI-LOOP::LOOP-COLLECTOR-HISTORY SYSTEM::FIX-LOAD-PATH
-         SYSTEM::COMPUTING-ARGS-P
-         ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE COMMON-LISP::TENTH
-         ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE SYSTEM::WILD-NAMESTRING-P
-         SYSTEM::BEST-ARRAY-ELEMENT-TYPE SYSTEM::DM-BAD-KEY
-         SYSTEM::TERMINAL-INTERRUPT SYSTEM::REGEXP-CONV
-         COMMON-LISP::FILE-WRITE-DATE SLOOP::PARSE-LOOP
-         ANSI-LOOP::LOOP-CONSTRUCT-RETURN SYSTEM::DWIM
+         SYSTEM::DIRECTORY-LIST-CHECK COMMON-LISP::FILE-WRITE-DATE
+         SYSTEM::NORMALIZE-TYPE COMMON-LISP::EIGHTH SYSTEM::TOGGLE-CASE
+         SYSTEM::SHOW-ENVIRONMENT
+         COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM SYSTEM::GET-PATH
+         COMMON-LISP::ASINH SYSTEM::FIND-KCL-TOP-RESTART
+         SYSTEM::RESTART-P SYSTEM::EVAL-FEATURE SYSTEM::ALOAD
+         COMMON-LISP::PHASE SLOOP::SUBSTITUTE-SLOOP-BODY
+         COMMON-LISP::ASIN SYSTEM::NODES-FROM-INDEX
+         SYSTEM::MAKE-DEFPACKAGE-FORM ANSI-LOOP::LOOP-COLLECTOR-DTYPE
+         SYSTEM::LOGICAL-PATHNAMEP SYSTEM::INSPECT-VECTOR
          ANSI-LOOP::LOOP-UNIVERSE-TYPE-KEYWORDS
-         SLOOP::RETURN-SLOOP-MACRO SLOOP::AVERAGING-SLOOP-MACRO
-         SYSTEM::S-DATA-NAME SYSTEM::CHECK-TRACE-SPEC
-         SYSTEM::RESTRICT-STREAM-ELEMENT-TYPE SLOOP::TRANSLATE-NAME
-         SYSTEM::ADD-TO-HOTLIST SYSTEM::S-DATA-CONC-NAME
-         ANSI-LOOP::LOOP-MINIMAX-TYPE SYSTEM::PRINT-IHS
-         SYSTEM::DBL-RPL-LOOP SYSTEM::CANONICALIZE-PATHNAME-DIRECTORY
-         SYSTEM::INSPECT-CONS SYSTEM::INSTREAM-STREAM-NAME
-         SYSTEM::S-DATA-P SYSTEM::EVAL-FEATURE
-         COMMON-LISP::ARRAY-DIMENSIONS SYSTEM::IHS-VISIBLE
-         ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE
-         SYSTEM::CHECK-DECLARATIONS COMMON-LISP::TANH
-         ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS
-         COMMON-LISP::COMPILE-FILE-PATHNAME SYSTEM::INSPECT-PACKAGE
-         SLOOP::LOOP-LET-BINDINGS COMMON-LISP::CIS SYSTEM::SETUP-INFO
-         SYSTEM::NORMALIZE-TYPE ANSI-LOOP::LOOP-PSEUDO-BODY
-         SYSTEM::PATH-STREAM-NAME SYSTEM::INFO-GET-TAGS FPE::ST-LOOKUP
-         SYSTEM::BREAK-BACKWARD-SEARCH-STACK
-         ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE SYSTEM::SIMPLE-ARRAY-P
-         SYSTEM::S-DATA-TYPE COMMON-LISP::CONCATENATED-STREAM-STREAMS
-         SYSTEM::INSPECT-CHARACTER ANSI-LOOP::DESTRUCTURING-SIZE
-         SYSTEM::GET-BYTE-STREAM-NCHARS ANSI-LOOP::LOOP-PATH-P
-         COMMON-LISP::FIRST COMMON-LISP::SECOND
-         COMMON-LISP::TWO-WAY-STREAM-INPUT-STREAM
-         SYSTEM::MAKE-DEFPACKAGE-FORM SYSTEM::INSPECT-SYMBOL
-         SYSTEM::INSPECT-VECTOR
-         COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS
-         SYSTEM::RESTART-INTERACTIVE-FUNCTION SYSTEM::INSPECT-STRING
-         SYSTEM::DIR-P ANSI-LOOP::LOOP-COLLECTOR-CLASS
-         SYSTEM::S-DATA-CONSTRUCTORS SYSTEM::NODES-FROM-INDEX
-         SYSTEM::VERSION-PARSE SYSTEM::BKPT-FILE-LINE COMMON-LISP::ABS
-         SYSTEM::IHS-FNAME ANSI-LOOP::LOOP-MAKE-PSETQ
-         SYSTEM::LEAP-YEAR-P ANSI-LOOP::LOOP-EMIT-FINAL-VALUE
-         SYSTEM::GET-PATH SYSTEM::ALOAD SYSTEM::DM-KEY-NOT-ALLOWED
-         SYSTEM::MAKE-KCL-TOP-RESTART SYSTEM::S-DATA-SLOT-DESCRIPTIONS
-         COMMON-LISP::VECTOR-POP ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS
-         ANSI-LOOP::LOOP-PATH-USER-DATA SYSTEM::S-DATA-SLOT-POSITION
-         COMMON-LISP::BROADCAST-STREAM-STREAMS
-         SYSTEM::LOGICAL-PATHNAMEP SYSTEM::BREAK-FORWARD-SEARCH-STACK
-         SLOOP::SLOOP-SLOOP-MACRO COMMON-LISP::SIGNUM
-         SYSTEM::RESET-TRACE-DECLARATIONS SYSTEM::CONTEXT-P
-         SYSTEM::S-DATA-FROZEN SYSTEM::NUMBER-OF-DAYS-FROM-1900
-         SYSTEM::S-DATA-STATICP ANSI-LOOP::LOOP-PATH-FUNCTION
-         SYSTEM::KNOWN-TYPE-P COMMON-LISP::PROVIDE SYSTEM::PNL1
-         ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD
-         SYSTEM::COERCE-SLASH-TERMINATED COMMON-LISP::LOGICAL-PATHNAME
-         SYSTEM::DIR-CONJ SYSTEM::BKPT-FORM
-         SYSTEM::LOGICAL-PATHNAME-HOST-P SYSTEM::INSPECT-STRUCTURE
-         ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED
-         COMMON-LISP::FIND-ALL-SYMBOLS
+         SYSTEM::RESTART-REPORT-FUNCTION SYSTEM::IHS-VISIBLE
+         SLOOP::LOOP-COLLECT-KEYWORD-P ANSI-LOOP::LOOP-TYPED-INIT
+         COMMON-LISP::VECTOR-POP SYSTEM::UNIQUE-ID
          ANSI-LOOP::LOOP-UNIVERSE-ITERATION-KEYWORDS
-         ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED
+         SYSTEM::SIMPLE-ARRAY-P COMMON-LISP::ACOS SYSTEM::DBL-EVAL
+         SYSTEM::INSPECT-STRING SYSTEM::MLP
+         SYSTEM::INSTREAM-STREAM-NAME SYSTEM::WILD-NAMESTRING-P
+         ANSI-LOOP::LOOP-PATH-FUNCTION
+         SYSTEM::GET-STRING-INPUT-STREAM-INDEX
+         ANSI-LOOP::LOOP-MINIMAX-TEMP-VARIABLE SYSTEM::SEQTYPE
+         ANSI-LOOP::LOOP-UNIVERSE-KEYWORDS
+         SYSTEM::BEST-ARRAY-ELEMENT-TYPE
+         ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA SYSTEM::S-DATA-FROZEN
+         SYSTEM::S-DATA-DOCUMENTATION SYSTEM::DWIM COMMON-LISP::SIGNUM
+         SYSTEM::FIND-DOCUMENTATION ANSI-LOOP::LOOP-COLLECTOR-HISTORY
+         ANSI-LOOP::LOOP-MAKE-PSETQ FPE::GREF SYSTEM::S-DATA-OFFSET
+         SYSTEM::WILD-PATH-ELEMENT-P SYSTEM::INSTREAM-P
+         COMMON-LISP::DIRECTORY-NAMESTRING SYSTEM::INSPECT-ARRAY
+         COMMON-LISP::ARRAY-DIMENSIONS
+         ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS ANSI-LOOP::LOOP-MINIMAX-P
+         SLOOP::RETURN-SLOOP-MACRO SYSTEM::WALK-THROUGH
+         SYSTEM::NEXT-STACK-FRAME SYSTEM::S-DATA-NAME COMMON-LISP::TANH
+         SYSTEM::BREAK-BACKWARD-SEARCH-STACK COMMON-LISP::TENTH
+         SYSTEM::INFO-NODE-FROM-POSITION FPE::ST-LOOKUP
+         COMMON-LISP::RESTART-NAME SYSTEM::S-DATA-TYPE
+         SYSTEM::BKPT-FILE-LINE COMMON-LISP::FIND-ALL-SYMBOLS
+         COMMON-LISP::FIFTH SLOOP::LOOP-LET-BINDINGS
+         COMMON-LISP::ECHO-STREAM-INPUT-STREAM
+         ANSI-LOOP::LOOP-UNIVERSE-IMPLICIT-FOR-REQUIRED
+         COMMON-LISP::PROBE-FILE SYSTEM::MAKE-FRAME
+         SYSTEM::IHS-NOT-INTERPRETED-ENV SYSTEM::SEARCH-STACK
+         COMMON-LISP::COMPILE-FILE-PATHNAME
+         SYSTEM::PRINT-SYMBOL-APROPOS COMMON-LISP::LOGNOT
+         SYSTEM::INFO-GET-TAGS SYSTEM::SHORT-NAME
+         ANSI-LOOP::LOOP-MINIMAX-TYPE COMMON-LISP::SIXTH
+         COMMON-LISP::SECOND ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS
+         COMMON-LISP::TWO-WAY-STREAM-OUTPUT-STREAM
+         SYSTEM::S-DATA-INCLUDES SYSTEM::RESTART-INTERACTIVE-FUNCTION
+         SLOOP::TRANSLATE-NAME SYSTEM::PATCH-SHARP COMMON-LISP::ABS
+         ANSI-LOOP::LOOP-CONSTANTP SYSTEM::LEAP-YEAR-P
+         ANSI-LOOP::LOOP-UNIVERSE-ANSI ANSI-LOOP::LOOP-EMIT-BODY
+         COMMON-LISP::HOST-NAMESTRING COMMON-LISP::FIRST
+         SYSTEM::INSERT-BREAK-POINT
+         COMMON-LISP::LOAD-LOGICAL-PATHNAME-TRANSLATIONS
+         COMMON-LISP::DELETE-FILE ANSI-LOOP::LOOP-PSEUDO-BODY
+         SYSTEM::GET-NEXT-VISIBLE-FUN SYSTEM::S-DATA-HAS-HOLES
+         ANSI-LOOP::LOOP-COLLECTOR-NAME COMMON-LISP::FOURTH
+         SYSTEM::BKPT-FILE SYSTEM::CANONICALIZE-PATHNAME-DIRECTORY
+         SYSTEM::INSTREAM-STREAM SYSTEM::PNL1 SYSTEM::IHS-FNAME
+         SYSTEM::S-DATA-SLOT-POSITION SLOOP::PARSE-LOOP
+         SYSTEM::CHECK-TRACE-SPEC SYSTEM::S-DATA-CONSTRUCTORS
+         SYSTEM::S-DATA-STATICP SYSTEM::CONTEXT-P
          COMMON-LISP::LOGICAL-PATHNAME-TRANSLATIONS
-         SYSTEM::TRACE-ONE-PREPROCESS COMMON-LISP::CONSTANTLY
-         COMMON-LISP::ACOS SYSTEM::S-DATA-OFFSET COMMON-LISP::ASINH
-         SYSTEM::SHORT-NAME SYSTEM::S-DATA-INCLUDED SYSTEM::DBL-EVAL
-         SYSTEM::BKPT-FUNCTION SYSTEM::INSPECT-NUMBER
-         SYSTEM::GET-INSTREAM SYSTEM::SHOW-BREAK-POINT FPE::LOOKUP
-         SYSTEM::NEXT-STACK-FRAME SYSTEM::INSPECT-ARRAY
-         SYSTEM::S-DATA-RAW ANSI-LOOP::LOOP-MINIMAX-INFINITY-DATA
-         SYSTEM::RESTART-REPORT-FUNCTION SYSTEM::TOGGLE-CASE
-         SYSTEM::NODE-OFFSET SYSTEM::INSTREAM-P
-         ANSI-LOOP::LOOP-PATH-NAMES SYSTEM::FREEZE-DEFSTRUCT
-         COMMON-LISP::SEVENTH SYSTEM::SEARCH-STACK COMMON-LISP::SIXTH
-         ANSI-LOOP::LOOP-UNIVERSE-TYPE-SYMBOLS FPE::GREF
-         FPE::XMM-LOOKUP COMMON-LISP::HOST-NAMESTRING
-         ANSI-LOOP::LOOP-TYPED-INIT
+         SYSTEM::INFO-GET-FILE COMMON-LISP::COMPLEMENT
+         SYSTEM::INSPECT-NUMBER SYSTEM::RESET-TRACE-DECLARATIONS
+         ANSI-LOOP::LOOP-PATH-P SLOOP::REPEAT-SLOOP-MACRO SYSTEM::DO-F
+         SYSTEM::INSPECT-PACKAGE SYSTEM::PATH-STREAM-NAME
+         SYSTEM::GET-INSTREAM COMMON-LISP::BYTE-SIZE
+         SYSTEM::RESTART-FUNCTION FPE::LOOKUP SYSTEM::S-DATA-CONC-NAME
+         COMMON-LISP::PROVIDE SYSTEM::S-DATA-NAMED SYSTEM::PRINT-FRS
+         ANSI-LOOP::LOOP-MINIMAX-ANSWER-VARIABLE SYSTEM::NODE-OFFSET
+         ANSI-LOOP::MAKE-ANSI-LOOP-UNIVERSE SYSTEM::PRINT-IHS
+         ANSI-LOOP::LOOP-UNIVERSE-PATH-KEYWORDS COMMON-LISP::TRUENAME
+         SYSTEM::BREAK-FORWARD-SEARCH-STACK
+         COMMON-LISP::CONCATENATED-STREAM-STREAMS SYSTEM::VERSION-PARSE
+         SYSTEM::INSPECT-CHARACTER SYSTEM::LOGICAL-PATHNAME-HOST-P
+         SYSTEM::DM-BAD-KEY SYSTEM::EXPAND-HOME-DIR
+         ANSI-LOOP::LOOP-PATH-USER-DATA
+         ANSI-LOOP::LOOP-PATH-PREPOSITION-GROUPS SYSTEM::INSPECT-SYMBOL
+         COMMON-LISP::INVOKE-DEBUGGER
          SYSTEM::LOGICAL-PATHNAME-DESIGNATOR-P
-         ANSI-LOOP::LOOP-DO-THEREIS COMMON-LISP::EIGHTH
-         SYSTEM::UNIQUE-ID COMMON-LISP::THIRD
-         COMMON-LISP::BYTE-POSITION COMMON-LISP::SYNONYM-STREAM-SYMBOL
-         SYSTEM::PATCH-SHARP SYSTEM::PRINT-SYMBOL-APROPOS
-         COMMON-LISP::LOGNOT SLOOP::REPEAT-SLOOP-MACRO
-         COMMON-LISP::FOURTH SLOOP::SUBSTITUTE-SLOOP-BODY
-         COMMON-LISP::ATANH SLOOP::LOOP-COLLECT-KEYWORD-P
-         SYSTEM::SEQTYPE SYSTEM::RE-QUOTE-STRING COMMON-LISP::ISQRT
-         SYSTEM::DO-F SYSTEM::S-DATA-HAS-HOLES
-         ANSI-LOOP::LOOP-HACK-ITERATION ANSI-LOOP::LOOP-COLLECTOR-NAME
-         COMMON-LISP::RESTART-NAME COMMON-LISP::DIRECTORY-NAMESTRING
-         ANSI-LOOP::LOOP-EMIT-BODY COMMON-LISP::ACOSH
-         SYSTEM::RESTART-FUNCTION SYSTEM::INFO-NODE-FROM-POSITION
-         COMMON-LISP::ASIN ANSI-LOOP::LOOP-LIST-COLLECTION
-         SYSTEM::S-DATA-INCLUDES SYSTEM::GET-NEXT-VISIBLE-FUN
-         COMMON-LISP::BYTE-SIZE COMMON-LISP::PATHNAME
-         ANSI-LOOP::LOOP-MINIMAX-P SLOOP::PARSE-LOOP-INITIALLY
-         COMMON-LISP::COSH SYSTEM::EXPAND-HOME-DIR
-         COMMON-LISP::ECHO-STREAM-INPUT-STREAM
-         SYSTEM::INSERT-BREAK-POINT SYSTEM::RESTART-TEST-FUNCTION
-         SYSTEM::S-DATA-PRINT-FUNCTION SYSTEM::WILD-DIR-ELEMENT-P
-         SYSTEM::S-DATA-NAMED COMMON-LISP::INVOKE-DEBUGGER
-         COMMON-LISP::NAMESTRING ANSI-LOOP::LOOP-MAKE-DESETQ
-         COMMON-LISP::COMPLEMENT SYSTEM::WALK-THROUGH
-         COMMON-LISP::RATIONAL ANSI-LOOP::LOOP-MAXMIN-COLLECTION
-         COMMON-LISP::DELETE-FILE ANSI-LOOP::LOOP-COLLECTOR-TEMPVARS)) 
+         COMMON-LISP::BYTE-POSITION COMMON-LISP::ISQRT COMMON-LISP::CIS
+         ANSI-LOOP::LOOP-COLLECTOR-CLASS
+         COMMON-LISP::SYNONYM-STREAM-SYMBOL ANSI-LOOP::LOOP-PATH-NAMES
+         SYSTEM::RE-QUOTE-STRING SYSTEM::INSPECT-STRUCTURE
+         COMMON-LISP::RATIONAL FPE::XMM-LOOKUP
+         SYSTEM::REWRITE-RESTART-CASE-CLAUSE
+         SYSTEM::S-DATA-PRINT-FUNCTION
+         SYSTEM::RESTRICT-STREAM-ELEMENT-TYPE SLOOP::SLOOP-SLOOP-MACRO
+         COMMON-LISP::NAMESTRING SYSTEM::ENSURE-DIR-STRING
+         COMMON-LISP::CONSTANTLY SLOOP::PARSE-LOOP-INITIALLY
+         SYSTEM::S-DATA-RAW SYSTEM::ADD-TO-HOTLIST SYSTEM::FRS-KIND
+         ANSI-LOOP::LOOP-MAXMIN-COLLECTION
+         ANSI-LOOP::LOOP-COLLECTOR-DATA SYSTEM::PROCESS-ARGS
+         SYSTEM::COERCE-SLASH-TERMINATED SYSTEM::MAKE-KCL-TOP-RESTART
+         COMMON-LISP::ATANH ANSI-LOOP::LOOP-CODE-DUPLICATION-THRESHOLD
+         COMMON-LISP::SINH ANSI-LOOP::LOOP-UNIVERSE-P
+         ANSI-LOOP::LOOP-PATH-INCLUSIVE-PERMITTED
+         SYSTEM::S-DATA-INCLUDED COMMON-LISP::STREAM-EXTERNAL-FORMAT
+         SYSTEM::COMPUTING-ARGS-P SYSTEM::REAL-ASINH
+         ANSI-LOOP::LOOP-CONSTRUCT-RETURN
+         SYSTEM::S-DATA-SLOT-DESCRIPTIONS SYSTEM::FIX-LOAD-PATH
+         SYSTEM::CHECK-DECLARATIONS
+         ANSI-LOOP::LOOP-UNIVERSE-FOR-KEYWORDS
+         SLOOP::POINTER-FOR-COLLECT COMMON-LISP::LOGICAL-PATHNAME
+         SYSTEM::CHDIR SYSTEM::IDESCRIBE
+         ANSI-LOOP::LOOP-MINIMAX-OPERATIONS COMMON-LISP::ACOSH
+         COMMON-LISP::NINTH ANSI-LOOP::LOOP-MINIMAX-FLAG-VARIABLE
+         ANSI-LOOP::LOOP-COLLECTOR-P SYSTEM::S-DATA-P SYSTEM::BKPT-FORM
+         COMMON-LISP::FILE-NAMESTRING SYSTEM::TERMINAL-INTERRUPT
+         SYSTEM::SETUP-INFO SLOOP::PARSE-NO-BODY
+         SYSTEM::DM-KEY-NOT-ALLOWED ANSI-LOOP::LOOP-EMIT-FINAL-VALUE
+         SYSTEM::FREEZE-DEFSTRUCT SYSTEM::DBL-RPL-LOOP
+         SYSTEM::TRACE-ONE-PREPROCESS
+         COMMON-LISP::BROADCAST-STREAM-STREAMS COMMON-LISP::THIRD
+         SLOOP::AVERAGING-SLOOP-MACRO SYSTEM::SHOW-BREAK-POINT
+         COMMON-LISP::PATHNAME ANSI-LOOP::LOOP-DO-THEREIS
+         COMMON-LISP::FILE-AUTHOR ANSI-LOOP::LOOP-MAKE-DESETQ
+         SYSTEM::NC SYSTEM::NUMBER-OF-DAYS-FROM-1900
+         SYSTEM::RESTART-TEST-FUNCTION SYSTEM::WHICH
+         ANSI-LOOP::DESTRUCTURING-SIZE COMMON-LISP::FILE-LENGTH)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*)
-         SYSTEM::BREAK-QUIT SYSTEM::BREAK-BDS SYSTEM::DBL-BACKTRACE
-         SYSTEM::BREAK-LOCAL SYSTEM::INFO-ERROR
-         SYSTEM::SHOW-BREAK-VARIABLES SYSTEM::BREAK-VS
-         COMMON-LISP::CONTINUE COMMON-LISP::MUFFLE-WARNING
-         SYSTEM::IHS-BACKTRACE ANSI-LOOP::LOOP-OPTIONAL-TYPE
-         SYSTEM::BREAK-PREVIOUS SYSTEM::BREAK-NEXT)) 
+         SYSTEM::BREAK-VS ANSI-LOOP::LOOP-OPTIONAL-TYPE
+         SYSTEM::BREAK-BDS SYSTEM::IHS-BACKTRACE SYSTEM::INFO-ERROR
+         SYSTEM::BREAK-LOCAL SYSTEM::SHOW-BREAK-VARIABLES
+         COMMON-LISP::MUFFLE-WARNING SYSTEM::BREAK-PREVIOUS
+         SYSTEM::BREAK-QUIT SYSTEM::DBL-BACKTRACE COMMON-LISP::CONTINUE
+         SYSTEM::BREAK-NEXT)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T))
+         SYSTEM::MAKE-KEYWORD)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             ((COMMON-LISP::INTEGER -9223372036854775808
-                  9223372036854775807)
-              COMMON-LISP::T)
+             (COMMON-LISP::T
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807)
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807)
+                 COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         SYSTEM::SMALLNTHCDR)) 
+         SYSTEM::QUICK-SORT)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             COMMON-LISP::HASH-TABLE)
-         SYSTEM::CONTEXT-SPICE)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807)
+                 COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::T)
+         SYSTEM::BIGNTHCDR)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM)
-         SYSTEM::S-DATA-SIZE FPE::REG-LOOKUP SYSTEM::INSTREAM-LINE
-         SYSTEM::S-DATA-LENGTH SYSTEM::THE-START)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::T)
+         COMMON-LISP::FIND-RESTART COMMON-LISP::PATHNAME-HOST
+         SYSTEM::LINK-EXPAND COMMON-LISP::CONCATENATE COMMON-LISP::WARN
+         COMMON-LISP::FILE-POSITION ANSI-LOOP::LOOP-WARN
+         COMMON-LISP::PATHNAME-DIRECTORY COMMON-LISP::SBIT
+         COMMON-LISP::BIT ANSI-LOOP::LOOP-COLLECT-PREPOSITIONAL-PHRASES
+         COMMON-LISP::PATHNAME-TYPE COMMON-LISP::MAKE-ARRAY
+         ANSI-LOOP::LOOP-ERROR COMMON-LISP::DIRECTORY SYSTEM::DIR-PARSE
+         COMMON-LISP::TRANSLATE-LOGICAL-PATHNAME
+         SYSTEM::NTH-STACK-FRAME COMMON-LISP::REQUIRE COMMON-LISP::LOAD
+         SYSTEM::MGLIST COMMON-LISP::DELETE-DUPLICATES
+         COMMON-LISP::PATHNAME-VERSION COMMON-LISP::ENOUGH-NAMESTRING
+         SYSTEM::BAD-SEQ-LIMIT COMMON-LISP::REMOVE-DUPLICATES
+         COMMON-LISP::PATHNAME-NAME
+         COMMON-LISP::MAKE-STRING-INPUT-STREAM SLOOP::LOOP-ADD-TEMPS
+         SYSTEM::NLOAD SYSTEM::LIST-MATCHES
+         COMMON-LISP::ARRAY-ROW-MAJOR-INDEX
+         COMMON-LISP::ARRAY-IN-BOUNDS-P SYSTEM::BREAK-LEVEL
+         SYSTEM::PROCESS-SOME-ARGS SYSTEM::TO-REGEXP
+         COMMON-LISP::UPGRADED-ARRAY-ELEMENT-TYPE COMMON-LISP::OPEN
+         SYSTEM::FILE-SEARCH COMMON-LISP::READ-BYTE
+         SYSTEM::FILE-TO-STRING SLOOP::ADD-FROM-DATA COMMON-LISP::ERROR
+         COMMON-LISP::SIGNAL SYSTEM::MGSUB COMMON-LISP::WILD-PATHNAME-P
+         COMMON-LISP::PATHNAME-DEVICE SYSTEM::LOGICAL-PATHNAME-PARSE
+         COMMON-LISP::MERGE-PATHNAMES SYSTEM::INFO-SEARCH
+         COMMON-LISP::BIT-NOT)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T)
-         SYSTEM::MATCH-BEGINNING SYSTEM::MATCH-END)) 
-(COMMON-LISP::MAPC
-    (COMMON-LISP::LAMBDA (COMPILER::X)
-      (COMMON-LISP::SETF
-          (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE)
-          COMMON-LISP::T))
-    '(SYSTEM::CONDITION-CLASS-P SYSTEM::WARNINGP SYSTEM::SI-CLASS-OF
-         SYSTEM::SI-FIND-CLASS SYSTEM::DEFINE-STRUCTURE
-         FPE::BREAK-ON-FLOATING-POINT-EXCEPTIONS
-         SYSTEM::SIMPLE-CONDITION-CLASS-P SYSTEM::AUTOLOAD
-         SYSTEM::SI-CLASS-PRECEDENCE-LIST SYSTEM::SI-CLASS-NAME
-         SYSTEM::TRACE-ONE SYSTEM::MAKE-ACCESS-FUNCTION
-         SYSTEM::UNTRACE-ONE SYSTEM::SI-CLASSP SYSTEM::CONDITIONP
-         SYSTEM::AUTOLOAD-MACRO)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         ANSI-LOOP::ESTIMATE-CODE-SIZE-1 SYSTEM::DO-REPL
+         SYSTEM::SOURCE-PORTION SYSTEM::RESTART-REPORT
+         SYSTEM::NEW-SEMI-COLON-READER SYSTEM::FIND-DOC
+         ANSI-LOOP::ESTIMATE-CODE-SIZE SYSTEM::NEWLINE
+         COMMON-LISP::RENAME-FILE SYSTEM::LIST-TOGGLE-CASE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             ((COMMON-LISP::INTEGER -9223372036854775808
-                  9223372036854775807))
-             COMMON-LISP::T)
-         SYSTEM::GET-CONTEXT SYSTEM::PUSH-CONTEXT)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::*)
+         COMMON-LISP::REDUCE COMMON-LISP::STABLE-SORT
+         SYSTEM::PARSE-BODY SLOOP::FIND-IN-ORDERED-LIST
+         COMMON-LISP::SUBTYPEP COMMON-LISP::SORT)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::FIXNUM)
-         SYSTEM::RELATIVE-LINE SYSTEM::LENEL SYSTEM::THE-END
-         ANSI-LOOP::DUPLICATABLE-CODE-P SYSTEM::FASLINK
-         SYSTEM::GET-NODE-INDEX)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         SYSTEM::LIST-MERGE-SORT ANSI-LOOP::LOOP-GET-COLLECTION-INFO
+         SYSTEM::SHARP---READER SYSTEM::SHARP-S-READER
+         SYSTEM::VERIFY-KEYWORDS SYSTEM::RESTART-PRINT
+         SYSTEM::SHARP-+-READER SYSTEM::READ-INSPECT-COMMAND)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T)
-         SLOOP::PARSE-ONE-WHEN-CLAUSE ANSI-LOOP::LOOP-DO-FINALLY
-         SLOOP::LOOP-PEEK ANSI-LOOP::LOOP-DO-INITIALLY SLOOP::LOOP-POP
-         ANSI-LOOP::LOOP-GET-PROGN SYSTEM::KCL-TOP-RESTARTS
-         SYSTEM::INSPECT-READ-LINE SLOOP::PARSE-LOOP-WHEN
-         ANSI-LOOP::LOOP-GET-FORM SYSTEM::DEFAULT-SYSTEM-BANNER
-         SYSTEM::SET-UP-TOP-LEVEL SYSTEM::GET-INDEX-NODE
-         ANSI-LOOP::LOOP-DO-DO ANSI-LOOP::LOOP-WHEN-IT-VARIABLE
-         SYSTEM::SETUP-LINEINFO COMMON-LISP::TYPE-ERROR
-         SYSTEM::READ-EVALUATED-FORM SYSTEM::INSPECT-INDENT-1
-         SLOOP::LOOP-UN-POP SLOOP::PARSE-LOOP-DO
-         ANSI-LOOP::LOOP-DO-WITH SYSTEM::INSPECT-INDENT
-         SYSTEM::GET-TEMP-DIR ANSI-LOOP::LOOP-ITERATION-DRIVER
-         SYSTEM::WINE-TMP-REDIRECT SLOOP::PARSE-LOOP-COLLECT
-         SYSTEM::DEFAULT-INFO-HOTLIST SLOOP::PARSE-LOOP1
-         SYSTEM::CLEANUP ANSI-LOOP::LOOP-DO-NAMED SYSTEM::DBL
-         SYSTEM::ALL-TRACE-DECLARATIONS SYSTEM::TEST-ERROR
-         ANSI-LOOP::LOOP-BIND-BLOCK ANSI-LOOP::LOOP-DO-REPEAT
-         SYSTEM::ILLEGAL-BOA SYSTEM::SET-ENV SYSTEM::SET-CURRENT
-         SYSTEM::INIT-BREAK-POINTS SYSTEM::GET-SIG-FN-NAME
-         ANSI-LOOP::LOOP-DO-RETURN ANSI-LOOP::LOOP-CONTEXT
-         SYSTEM::SHOW-RESTARTS SYSTEM::STEP-READ-LINE
-         SLOOP::PARSE-LOOP-FOR SYSTEM::DM-TOO-MANY-ARGUMENTS
-         COMMON-LISP::LISP-IMPLEMENTATION-VERSION SYSTEM::TOP-LEVEL
-         ANSI-LOOP::LOOP-POP-SOURCE SYSTEM::DM-TOO-FEW-ARGUMENTS)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         SYSTEM::PUSH-OPTIONAL-BINDING)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             ((COMMON-LISP::VECTOR COMMON-LISP::CHARACTER
-                  COMMON-LISP::*))
-             COMMON-LISP::T)
-         SYSTEM::RESET-SYS-PATHS)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
+             COMMON-LISP::*)
+         SYSTEM::TRACE-CALL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             (COMMON-LISP::VECTOR COMMON-LISP::T))
-         SYSTEM::CONTEXT-VEC)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::*)
+             COMMON-LISP::*)
+         SYSTEM::MASET)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::*)
+         SYSTEM::EXPAND-WILD-DIRECTORY)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::*)
+         SYSTEM::PARSE-DEFMACRO SYSTEM::PARSE-DEFMACRO-LAMBDA-LIST)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
+             COMMON-LISP::*)
+         SYSTEM::MME3)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             ((COMMON-LISP::INTEGER -9223372036854775808
+                  9223372036854775807)
+              COMMON-LISP::T)
+             COMMON-LISP::T)
+         SYSTEM::SMALLNTHCDR)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*)
-         SYSTEM::BREAK-HELP SYSTEM::BREAK-MESSAGE
-         SYSTEM::SIMPLE-BACKTRACE ANSI-LOOP::LOOP-DO-FOR
-         SYSTEM::BREAK-CURRENT SYSTEM::GCL-TOP-LEVEL
-         SYSTEM::BREAK-RESUME)) 
\ No newline at end of file
+         SYSTEM::GCL-TOP-LEVEL SYSTEM::BREAK-MESSAGE
+         SYSTEM::BREAK-RESUME SYSTEM::SIMPLE-BACKTRACE
+         SYSTEM::BREAK-HELP ANSI-LOOP::LOOP-DO-FOR
+         SYSTEM::BREAK-CURRENT)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM)
+         SYSTEM::S-DATA-LENGTH SYSTEM::THE-START SYSTEM::INSTREAM-LINE
+         SYSTEM::S-DATA-SIZE FPE::REG-LOOKUP)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T)
+         SYSTEM::MATCH-BEGINNING SYSTEM::MATCH-END)) 
\ No newline at end of file

diff --git a/o/fasdump.c b/o/fasdump.c
index 01f32217c30f9c2d12c18f3bb9609c4b8b6a664d..2ee5ec88f95ffb6d8fb8359bb1f6cae04c6e8933 100755 (executable)
--- a/o/fasdump.c
+++ b/o/fasdump.c
@@ -598,7 +598,7 @@ DEFUN_NEW("OPEN-FASD",object,fSopen_fasd,SI,4,4,NONE,OO,OO,OO,OO,(object stream,
       if(tabl==Cnil) tabl=funcall_cfun(Lmake_hash_table,2,sKtest,sLeq);
       else
        check_type(tabl,t_hashtable);}
-   check_type(str,t_stream);
+   massert(str==stream);
    result=alloc_simple_vector(sizeof(struct fasd)/sizeof(int),aet_object);
    array_allocself(result,1,Cnil);
    {struct fasd *fd= (struct fasd *)result->v.v_self;
@@ -608,7 +608,7 @@ DEFUN_NEW("OPEN-FASD",object,fSopen_fasd,SI,4,4,NONE,OO,OO,OO,OO,(object stream,
     fd->eof=eof;
     fd->index=small_fixnum(0);
     fd->package=symbol_value(sLApackageA);
-    fd->filepos = make_fixnum(file_position(stream));
+    fd->filepos = make_fixnum(ftell(stream->sm.sm_fp));
     
     SETUP_FASD_IN(fd);
     if (direction==sKoutput){
@@ -649,13 +649,13 @@ DEFUN_NEW("CLOSE-FASD",object,fSclose_fasd,SI,1,1,NONE,OO,OO,OO,OO,(object ar),"
        {clrhash(fd->table);
        SETUP_FASD_IN(fd);
        PUT_OP(d_end_of_file);
-       {int i = file_position(fd->stream);
+       {int i = ftell(fd->stream->sm.sm_fp);
         if(type_of(fd->filepos) == t_fixnum)
-         { file_position_set(fd->stream,fix(fd->filepos) +2);
+          { fseek(fd->stream->sm.sm_fp,fix(fd->filepos)+2,SEEK_SET);
            /* record the length of array needed to read the indices */
            PUT4(fix(fd->index));
            /* move back to where we were */
-           file_position_set(fd->stream,i);
+           fseek(fd->stream->sm.sm_fp,i,SEEK_SET);
          }}
         
       }

diff --git a/o/file.d b/o/file.d
index 2d51488dfd4b3223d3b3e514c11cde4cde119a61..29e56437c8482ee52ef8070908344124ed3e94f1 100755 (executable)
--- a/o/file.d
+++ b/o/file.d
@@ -167,7 +167,6 @@ BEGIN:
        case smm_probe:
                return(FALSE);
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -224,7 +223,6 @@ BEGIN:
        case smm_probe:
                return(FALSE);
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -272,7 +270,6 @@ BEGIN:
        case smm_socket:
            return (sLcharacter);
            
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -440,7 +437,7 @@ open_stream(object fn,enum smmode smm, object if_exists, object if_does_not_exis
   x->sm.sm_buffer = 0;
   x->sm.sm_object0 = sLcharacter;
   x->sm.sm_object1 = vs_head;
-  x->sm.sm_int0 = x->sm.sm_int1 = 0;
+  x->sm.sm_int = 0;
   x->sm.sm_flags=0;
   vs_push(x);
 
@@ -522,8 +519,6 @@ DEFUN_NEW("OPEN-STREAM-P",object,fLopen_stream_p,LISP,1,1,NONE,OO,OO,OO,OO,(obje
 void
 close_stream(object strm)  {
 
-  object x;
-
   if (FFN(fLopen_stream_p)(strm)==Cnil)
     return;
 
@@ -569,24 +564,15 @@ close_stream(object strm)  {
     strm->sm.sm_fd = -1;
     break;
 
-  case smm_file_synonym:
   case smm_synonym:
-    strm = symbol_value(strm->sm.sm_object0);
-    if (type_of(strm) != t_stream)
-      TYPE_ERROR(strm,sLstream);
-    close_stream(strm);
     break;
 
   case smm_broadcast:
   case smm_concatenated:
-    for (x = strm->sm.sm_object0; !endp(x); x = x->c.c_cdr)
-      close_stream(x->c.c_car);
     break;
 
   case smm_two_way:
   case smm_echo:
-    close_stream(STREAM_INPUT_STREAM(strm));
-    close_stream(STREAM_OUTPUT_STREAM(strm));
     break;
 
   case smm_string_input:
@@ -616,7 +602,6 @@ DEFUN_NEW("INTERACTIVE-STREAM-P",object,fLinteractive_stream_p,LISP,1,1,NONE,OO,
       return Ct;
     return Cnil;
     break;
-  case smm_file_synonym:
   case smm_synonym:
     strm = symbol_value(strm->sm.sm_object0);
     if (type_of(strm) != t_stream)
@@ -656,7 +641,7 @@ object istrm, ostrm;
        strm->sm.sm_buffer = 0;
        STREAM_INPUT_STREAM(strm) = istrm;
        STREAM_OUTPUT_STREAM(strm) = ostrm;
-       strm->sm.sm_int0 = strm->sm.sm_int1 = 0;
+       strm->sm.sm_int = 0;
        strm->sm.sm_flags=0;
        return(strm);
 }
@@ -672,24 +657,30 @@ object istrm, ostrm;
        return(strm);
 }
 
-object
-make_string_input_stream(strng, istart, iend)
-object strng;
-int istart, iend;
-{
-       object strm;
+DEFUN_NEW("MAKE-STRING-INPUT-STREAM-INT",object,fSmake_string_input_stream_int,SI,3,3,NONE,OO,II,OO,OO,
+         (object strng,fixnum istart,fixnum iend),"") {
+
+  object strm;
+
+  strm = alloc_object(t_stream);
+  strm->sm.sm_mode = (short)smm_string_input;
+  strm->sm.sm_fp = NULL;
+  strm->sm.sm_buffer = 0;
+  STRING_STREAM_STRING(strm) = strng;
+  strm->sm.sm_object1 = OBJNULL;
+  STRING_INPUT_STREAM_NEXT(strm)= istart;
+  STRING_INPUT_STREAM_END(strm)= iend;
+  strm->sm.sm_flags=0;
+
+  RETURN1(strm);
 
-       strm = alloc_object(t_stream);
-       strm->sm.sm_mode = (short)smm_string_input;
-       strm->sm.sm_fp = NULL;
-       strm->sm.sm_buffer = 0;
-       STRING_STREAM_STRING(strm) = strng;
-       strm->sm.sm_object1 = OBJNULL;
-       STRING_INPUT_STREAM_NEXT(strm)= istart;
-       STRING_INPUT_STREAM_END(strm)= iend;
-       strm->sm.sm_flags=0;
-       return(strm);
 }
+#ifdef STATIC_FUNCTION_POINTERS
+object
+fSmake_string_input_stream_int(object x,fixnum y,fixnum z) {
+  return FFN(fSmake_string_input_stream_int)(x,y,z);
+}
+#endif
 
 DEFUN_NEW("STRING-INPUT-STREAM-P",object,fSstring_input_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") {
   return type_of(x)==t_stream && x->sm.sm_mode == (short)smm_string_input ? Ct : Cnil;
@@ -722,7 +713,7 @@ int line_length;
        strm->sm.sm_buffer = 0;
        STRING_STREAM_STRING(strm) = strng;
        strm->sm.sm_object1 = OBJNULL;
-       strm->sm.sm_int0 = STREAM_FILE_COLUMN(strm) = 0;
+       strm->sm.sm_int = 0;
        strm->sm.sm_flags=0;
        vs_reset;
        return(strm);
@@ -777,7 +768,6 @@ BEGIN:
                /* strm->sm.sm_int0++; */
                return(c==EOF ? c : (c&0377));
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -880,7 +870,6 @@ BEGIN:
                /* --strm->sm.sm_int0; */  /* use ftell now for position */
                break;
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -982,7 +971,6 @@ BEGIN:
 
                break;
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -1093,7 +1081,6 @@ BEGIN:
 #endif
                  closed_stream(strm);
                break;
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -1182,7 +1169,6 @@ BEGIN:
        case smm_probe:
                return(FALSE);
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                check_stream(strm);
@@ -1308,7 +1294,6 @@ BEGIN:
 #endif
                return TRUE;
 
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -1344,136 +1329,6 @@ BEGIN:
        }
 }
 
-int
-file_position(strm)
-object strm;
-{
-BEGIN:
-       switch (strm->sm.sm_mode) {
-       case smm_input:
-       case smm_output:
-       case smm_io:
-               /*  return(strm->sm.sm_int0);  */
-               if (strm->sm.sm_fp == NULL)
-                       closed_stream(strm);
-               return(ftell(strm->sm.sm_fp));
-       case smm_socket:
-          return -1;
-         
-
-       case smm_string_output:
-               return(STRING_STREAM_STRING(strm)->st.st_fillp);
-
-       case smm_file_synonym:
-       case smm_synonym:
-               strm = symbol_value(strm->sm.sm_object0);
-               if (type_of(strm) != t_stream)
-                       FEwrong_type_argument(sLstream, strm);
-               goto BEGIN;
-
-       case smm_probe:
-       case smm_broadcast:
-       case smm_concatenated:
-       case smm_two_way:
-       case smm_echo:
-       case smm_string_input:
-               return(-1);
-
-       default:
-               error("illegal stream mode");
-               return(-1);
-       }
-}
-
-int
-file_position_set(strm, disp)
-object strm;
-int disp;
-{
-BEGIN:
-       switch (strm->sm.sm_mode) {
-       case smm_socket:
-         return -1;
-       case smm_input:
-       case smm_output:
-       case smm_io:
-
-               if (fseek(strm->sm.sm_fp, disp, 0) < 0)
-                       return(-1);
-               /* strm->sm.sm_int0 = disp; */
-               return(0);
-
-       case smm_string_output:
-               if (disp < STRING_STREAM_STRING(strm)->st.st_fillp) {
-                       STRING_STREAM_STRING(strm)->st.st_fillp = disp;
-                       /* strm->sm.sm_int0 = disp; */
-               } else {
-                       disp -= STRING_STREAM_STRING(strm)->st.st_fillp;
-                       while (disp-- > 0)
-                               writec_stream(' ', strm);
-               }
-               return(0);
-
-       case smm_file_synonym:
-       case smm_synonym:
-               strm = symbol_value(strm->sm.sm_object0);
-               if (type_of(strm) != t_stream)
-                       FEwrong_type_argument(sLstream, strm);
-               goto BEGIN;
-
-       case smm_probe:
-       case smm_broadcast:
-       case smm_concatenated:
-       case smm_two_way:
-       case smm_echo:
-       case smm_string_input:
-               return(-1);
-
-       default:
-               error("illegal stream mode");
-               return(-1);
-       }
-}
-
-static int
-file_length(strm)
-object strm;
-{
-BEGIN:
-       switch (strm->sm.sm_mode) {
-       case smm_input:
-       case smm_output:
-       case smm_io:
-
-               if (strm->sm.sm_fp == NULL)
-                       closed_stream(strm);
-               return(file_len(strm->sm.sm_fp));
-               
-
-         
-       case smm_file_synonym:
-       case smm_synonym:
-               strm = symbol_value(strm->sm.sm_object0);
-               if (type_of(strm) != t_stream)
-                       FEwrong_type_argument(sLstream, strm);
-               goto BEGIN;
-
-       case smm_socket:
-       case smm_probe:
-       case smm_broadcast:
-       case smm_concatenated:
-       case smm_two_way:
-       case smm_echo:
-       case smm_string_input:
-       case smm_string_output:
-               return(-1);
-
-       default:
-               error("illegal stream mode");
-               return(-1);
-       }
-}
-
 int
 file_column(object strm) {
        int i;
@@ -1491,7 +1346,6 @@ BEGIN:
        case smm_two_way:
            strm=STREAM_OUTPUT_STREAM(strm);
            goto BEGIN;
-       case smm_file_synonym:
        case smm_synonym:
                strm = symbol_value(strm->sm.sm_object0);
                if (type_of(strm) != t_stream)
@@ -1558,22 +1412,6 @@ load(const char *s) {
 
 \f
 
-static int
-file_synonym_stream_p(object x) {
-  switch(x->sm.sm_mode) {
-  case smm_input:
-  case smm_output:
-  case smm_io:
-  case smm_probe:
-  case smm_file_synonym:
-    return 1;
-  case smm_synonym:
-    return file_synonym_stream_p(x->sm.sm_object0->s.s_dbind);
-  default:
-    return 0;
-  }
-}
-
 LFD(Lmake_synonym_stream)()
 {
        object x;
@@ -1581,12 +1419,12 @@ LFD(Lmake_synonym_stream)()
        check_arg(1);
        check_type_sym(&vs_base[0]);
        x = alloc_object(t_stream);
-       x->sm.sm_mode = file_synonym_stream_p(vs_base[0]) ? (short)smm_file_synonym : (short)smm_synonym;
+       x->sm.sm_mode = (short)smm_synonym;
        x->sm.sm_fp = NULL;
        x->sm.sm_buffer = 0;
        x->sm.sm_object0 = vs_base[0];
        x->sm.sm_object1 = OBJNULL;
-       x->sm.sm_int0 = x->sm.sm_int1 = 0;
+       x->sm.sm_int = 0;
        x->sm.sm_flags=0;
        vs_base[0] = x;
 }
@@ -1610,7 +1448,7 @@ LFD(Lmake_broadcast_stream)()
        x->sm.sm_buffer = 0;
        x->sm.sm_object0 = vs_base[0];
        x->sm.sm_object1 = OBJNULL;
-       x->sm.sm_int0 = x->sm.sm_int1 = 0;
+       x->sm.sm_int = 0;
        x->sm.sm_flags=0;
        vs_base[0] = x;
 }
@@ -1634,7 +1472,7 @@ LFD(Lmake_concatenated_stream)()
        x->sm.sm_buffer = 0;
        x->sm.sm_object0 = vs_base[0];
        x->sm.sm_object1 = OBJNULL;
-       x->sm.sm_int0 = x->sm.sm_int1 = 0;
+       x->sm.sm_int = 0;
        x->sm.sm_flags=0;
        vs_base[0] = x;
 }
@@ -1667,32 +1505,6 @@ LFD(Lmake_echo_stream)()
        vs_popp;
 }
 
-@(static defun make_string_input_stream (strng &o istart iend)
-       int s, e;
-@
-       check_type_string(&strng);
-       if (istart == Cnil)
-               s = 0;
-       else if (type_of(istart) != t_fixnum)
-               goto E;
-       else
-               s = fix(istart);
-       if (iend == Cnil)
-               e = strng->st.st_fillp;
-       else if (type_of(iend) != t_fixnum)
-               goto E;
-       else
-               e = fix(iend);
-       if (s < 0 || e > strng->st.st_fillp || s > e)
-               goto E;
-       @(return `make_string_input_stream(strng, s, e)`)
-
-E:
-       FEerror("~S and ~S are illegal as :START and :END~%\
-for the string ~S.",
-               3, istart, iend, strng);
-@)
-
 @(static defun make_string_output_stream (&k element_type)
 @
         element_type=Cnil;/*FIXME*/
@@ -1724,12 +1536,29 @@ LFD(siLoutput_stream_string)()
        vs_base[0] = vs_base[0]->sm.sm_object0;
 }
 
+object
+file_stream(object x) {
+  if (type_of(x)==t_stream)
+    switch(x->sm.sm_mode) {
+    case smm_input:
+    case smm_output:
+    case smm_io:
+    case smm_probe:
+      return x;
+    case smm_synonym:
+      return file_stream(x->sm.sm_object0->s.s_dbind);
+    default:
+      break;
+  }
+  return Cnil;
+}
+
 DEFUN_NEW("FILE-STREAM-P",object,fSfile_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") {
-  RETURN1(type_of(x)==t_stream && file_synonym_stream_p(x) ? Ct : Cnil);
+  RETURN1(file_stream(x)!=Cnil ? Ct : Cnil);
 }
 
 DEFUN_NEW("SYNONYM-STREAM-P",object,fSsynonym_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") {
-  RETURN1(type_of(x)==t_stream && (x->sm.sm_mode==smm_file_synonym || x->sm.sm_mode==smm_synonym) ? Ct : Cnil);
+  RETURN1(type_of(x)==t_stream && x->sm.sm_mode==smm_synonym ? Ct : Cnil);
 }
 
 DEFUN_NEW("TERMINAL-INPUT-STREAM-P",object,fSterminal_input_stream_p,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") {
@@ -1802,43 +1631,6 @@ LFD(Lstream_element_type)()
 @)
 
 
-@(defun file_position (file_stream &o position)
-       int i=0;
-@
-       check_type_stream(&file_stream);
-       if (position == Cnil) {
-               i = file_position(file_stream);
-               if (i < 0)
-                       @(return Cnil)
-               @(return `make_fixnum(i)`)
-       } else {
-               if (position == sKstart)
-                       i = 0;
-               else if (position == sKend)
-                       i = file_length(file_stream);
-               else if (type_of(position) != t_fixnum ||
-                   (i = fix((position))) < 0)
-                       FEerror("~S is an illegal file position~%\
-for the file-stream ~S.",
-                               2, position, file_stream);
-               if (file_position_set(file_stream, i) < 0)
-                       @(return Cnil)
-               @(return Ct)
-       }       
-@)
-
-LFD(Lfile_length)()
-{
-       int i;
-
-       check_arg(1);
-       check_type_stream(&vs_base[0]);
-       i = file_length(vs_base[0]);
-       if (i < 0)
-               vs_base[0] = Cnil;
-       else
-               vs_base[0] = make_fixnum(i);
-}
 
 object sLAload_pathnameA;
 DEFVAR("*COLLECT-BINARY-MODULES*",sSAcollect_binary_modulesA,SI,sLnil,"");
@@ -1911,17 +1703,6 @@ DEFUN_NEW("LOAD-FASL",object,fSload_fasl,SI,2,2,NONE,OO,OO,OO,OO,(object fasl_fi
 
 }
 
-static void
-FFN(siLget_string_input_stream_index)()
-{
-       check_arg(1);
-       check_type_stream(&vs_base[0]);
-       if ((enum smmode)vs_base[0]->sm.sm_mode != smm_string_input)
-               FEerror("~S is not a string-input stream.", 1, vs_base[0]);
-       vs_base[0] = make_fixnum(STRING_INPUT_STREAM_NEXT(vs_base[0]));
-}
-
-
 LFD(siLmake_string_output_stream_from_string)()
 {
        object strng, strm;
@@ -2042,7 +1823,6 @@ int out;
  if (type_of(strm) != t_stream)
    FEwrong_type_argument(sLstream, strm);
  switch (strm->sm.sm_mode){
- case smm_file_synonym:
  case smm_synonym:
   strm = symbol_value(strm->sm.sm_object0);
   if (type_of(strm) != t_stream)
@@ -2203,7 +1983,7 @@ object async;
   x->sm.sm_buffer = 0;
   x->sm.sm_object0 = list(3,server,host,port);
   x->sm.sm_object1 = 0;
-  x->sm.sm_int0 = x->sm.sm_int1 = 0;
+  x->sm.sm_int = 0;
   x->sm.sm_flags=0;
   SOCKET_STREAM_FD(x)= fd;
   SET_STREAM_FLAG(x,mode,1);
@@ -2466,8 +2246,7 @@ gcl_init_file(void)
 #ifdef UNIX
        = make_simple_string("stdin");
 #endif
-       standard_input->sm.sm_int0 = 0; /* unused */
-       standard_input->sm.sm_int1 = 0; /* unused */
+       standard_input->sm.sm_int = 0; /* unused */
        standard_input->sm.sm_flags=0;
 
        standard_output = alloc_object(t_stream);
@@ -2479,8 +2258,7 @@ gcl_init_file(void)
 #ifdef UNIX
        = make_simple_string("stdout");
 #endif
-       standard_output->sm.sm_int0 = 0; /* unused */
-       STREAM_FILE_COLUMN(standard_output) = 0;
+       standard_output->sm.sm_int = 0; /* unused */
        standard_output->sm.sm_flags=0;
 
        terminal_io = standard
@@ -2488,12 +2266,12 @@ gcl_init_file(void)
        enter_mark_origin(&terminal_io);
 
        x = alloc_object(t_stream);
-       x->sm.sm_mode = (short)smm_file_synonym;
+       x->sm.sm_mode = (short)smm_synonym;
        x->sm.sm_fp = NULL;
        x->sm.sm_buffer = 0;
        x->sm.sm_object0 = sLAterminal_ioA;
        x->sm.sm_object1 = OBJNULL;
-       x->sm.sm_int0 = x->sm.sm_int1 = 0; /* unused */
+       x->sm.sm_int = 0; /* unused */
        x->sm.sm_flags=0;
        standard_io = x;
        enter_mark_origin(&standard_io);        
@@ -2561,8 +2339,6 @@ gcl_init_file_function()
                      Lmake_concatenated_stream);
        make_function("MAKE-TWO-WAY-STREAM", Lmake_two_way_stream);
        make_function("MAKE-ECHO-STREAM", Lmake_echo_stream);
-       make_function("MAKE-STRING-INPUT-STREAM",
-                     Lmake_string_input_stream);
        make_function("MAKE-STRING-OUTPUT-STREAM",
                      Lmake_string_output_stream);
        make_function("GET-OUTPUT-STREAM-STRING",
@@ -2581,11 +2357,6 @@ gcl_init_file_function()
        make_function("STREAM-ELEMENT-TYPE", Lstream_element_type);
        make_function("CLOSE", Lclose);
 
-       make_function("FILE-POSITION", Lfile_position);
-       make_function("FILE-LENGTH", Lfile_length);
-
-       make_si_function("GET-STRING-INPUT-STREAM-INDEX",
-                        siLget_string_input_stream_index);
        make_si_function("MAKE-STRING-OUTPUT-STREAM-FROM-STRING",
                         siLmake_string_output_stream_from_string);
        make_si_function("COPY-STREAM", siLcopy_stream);

diff --git a/o/gbc.c b/o/gbc.c
index dd2f5a02cf12407396329336522b4affbf8c5053..df0e990980a8c449b3eaf8503492295c5489f4a8 100755 (executable)
--- a/o/gbc.c
+++ b/o/gbc.c
@@ -627,7 +627,6 @@ mark_object1(object x) {
       }
       break;
 
-    case smm_file_synonym:
     case smm_synonym:
       mark_object(x->sm.sm_object0);
       break;

diff --git a/o/pathname.d b/o/pathname.d
index b236d78949cb37161da8b658042d2af15a5eb39b..3c75882e5b957815ed5fe5f48b83a75e294787f9 100755 (executable)
--- a/o/pathname.d
+++ b/o/pathname.d
@@ -83,6 +83,11 @@ DEFUN_NEW("C-STREAM-OBJECT1",object,fSc_stream_object1,SI,1,1,NONE,OO,OO,OO,OO,(
   RETURN1(x->sm.sm_object1);
 }
 
+DEFUN_NEW("C-SET-STREAM-OBJECT0",object,fSc_set_stream_object0,SI,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
+  x->sm.sm_object0=y;
+  RETURN1(x);
+}
+
 DEFUN_NEW("C-SET-STREAM-OBJECT1",object,fSc_set_stream_object1,SI,2,2,NONE,OO,OO,OO,OO,(object x,object y),"") {
   x->sm.sm_object1=y;
   RETURN1(x);

diff --git a/o/print.d b/o/print.d
index 9f256d30f917f624c17909507659f948fa012d22..e5fe774ed007414c4ee02c8fb1d907b0415e025a 100755 (executable)
--- a/o/print.d
+++ b/o/print.d
@@ -1260,7 +1260,6 @@ int level;
                        write_ch('>');
                        break;
 
-               case smm_file_synonym:
                case smm_synonym:
                        write_str("#<synonym stream to ");
                        write_object(x->sm.sm_object0, level);

diff --git a/o/read.d b/o/read.d
index 00c98225ef06baeac4171069ab4bb51307e61b53..7c8e2318e96b877c32caf4480f2604d79752fb8e 100755 (executable)
--- a/o/read.d
+++ b/o/read.d
@@ -2204,7 +2204,7 @@ object x;
        object in;
        vs_mark;
 
-       in = make_string_input_stream(x, 0, x->st.st_fillp);
+       in = fSmake_string_input_stream_int(x, 0, x->st.st_fillp);
        vs_push(in);
        preserving_whitespace_flag = FALSE;
        detect_eos_flag = FALSE;

diff --git a/o/run_process.c b/o/run_process.c
index 288d6de21754099e754bd385b03903da3393f4c6..6c4243dc618522d85525fc6cbac27a74af3a6abd 100755 (executable)
--- a/o/run_process.c
+++ b/o/run_process.c
@@ -434,7 +434,7 @@ enum smmode smm;
 
        stream->sm.sm_object0 = sLcharacter;
        stream->sm.sm_object1 = host_l;
-       stream->sm.sm_int0 = stream->sm.sm_int1 = 0;
+       stream->sm.sm_int = 0;
        stream->sm.sm_flags=0;
        vs_push(stream);
        setup_stream_buffer(stream);
@@ -503,8 +503,7 @@ make_socket_pair()
   stream_in->sm.sm_mode = smm_input;
   stream_in->sm.sm_fp = fp1;
   stream_in->sm.sm_buffer = 0;
-  stream_in->sm.sm_int0 = sockets_in[1];
-  stream_in->sm.sm_int1 = 0;
+  stream_in->sm.sm_int = sockets_in[1];
   stream_in->sm.sm_object0=stream_in->sm.sm_object1=OBJNULL;
   stream_in->sm.sm_flags = 0;
   stream_out = (object) alloc_object(t_stream);
@@ -513,8 +512,7 @@ make_socket_pair()
   stream_out->sm.sm_buffer = 0;
   setup_stream_buffer(stream_in);
   setup_stream_buffer(stream_out);
-  stream_out->sm.sm_int0 = sockets_out[1];
-  stream_out->sm.sm_int1 = 0;
+  stream_out->sm.sm_int = sockets_out[1];
   stream_out->sm.sm_flags = 0;
   stream_out->sm.sm_object0=stream_out->sm.sm_object1=OBJNULL;
   stream = make_two_way_stream(stream_in, stream_out);
@@ -538,8 +536,8 @@ char **argv;
   int fdout;
   if (istream->sm.sm_fp == NULL || ostream->sm.sm_fp == NULL)
     FEerror("Cannot spawn process with given stream", 0);
-  fdin = istream->sm.sm_int0;
-  fdout = ostream->sm.sm_int0;
+  fdin = istream->sm.sm_int;
+  fdout = ostream->sm.sm_int;
   if (pfork() == 0)
     { /* the child --- replace standard in and out with descriptors given */
       close(0);

diff --git a/o/sockets.c b/o/sockets.c
index 512771dc5a0cc00b1546014ac299b23a01d287a4..a38885765d51bebcbd127941f76f1dce54643dfb 100755 (executable)
--- a/o/sockets.c
+++ b/o/sockets.c
@@ -518,16 +518,6 @@ DEFUN_NEW("SET-SIGIO-FOR-FD",object,fSset_sigio_for_fd,SI,1,1,NONE,OI,OO,OO,OO,(
 
 }
      
-DEFUN_NEW("RESET-STRING-INPUT-STREAM",object,fSreset_string_input_stream,SI,4,4,NONE,OO,OI,IO,OO,(object strm,object string,fixnum start,fixnum end),
-      "Reuse a string output STREAM by setting its output to STRING \
-and positioning the ouput/input to start at START and end at END")
-
-{ strm->sm.sm_object0 = string;
-  strm->sm.sm_int0 = start;
-  strm->sm.sm_int1 = end;
-  return strm;
-}
-
 DEFUN_NEW("CHECK-STATE-INPUT",object,fScheck_state_input,SI,2,2,NONE,OO,IO,OO,OO,(object osfd,fixnum timeout),
       "") 
 {

diff --git a/o/string.d b/o/string.d
index c262b17e47c86bbf25e4da9d813bc1be3457beec..4c76c71c828bade0c581033b18bf5353dd8f4175 100755 (executable)
--- a/o/string.d
+++ b/o/string.d
@@ -564,28 +564,33 @@ LFD(Lnstring_capitalize)() { casefun = char_capitalize;  FFN(Lnstring_case)(); }
        @(return `coerce_to_string(x)`)
 @)
 
-static void
-FFN(siLstring_concatenate)()
-{
-       int narg, i, l, m;
-       object *v;
+DEFUN_NEW("STRING-CONCATENATE",object,fLstring_concatenate,SI,0,63,NONE,OO,OO,OO,OO,(object first,...),"") {
+
+  fixnum i,l,m,narg=VFUN_NARGS;
+  object x;
+  va_list ap;
+
+  va_start(ap,first);
+  vs_base=vs_top;
+  for (l=i=0;i<narg;i++) {
+    vs_push(coerce_to_string(i ? va_arg(ap,object) : first));
+    l += vs_head->st.st_fillp;
+  }
+  va_end(ap);
+
+  {
+    object *p;
+    BEGIN_NO_INTERRUPT;
+    x=alloc_simple_string(l);
+    (x)->st.st_self = alloc_relblock(l);
+    for (l=0,p=vs_base;p<vs_top && (m=(*p)->st.st_fillp)>=0;p++,l+=m)
+      memcpy(x->st.st_self+l,(*p)->st.st_self,m);
+    END_NO_INTERRUPT;
+
+  }
+
+  RETURN1(x);
 
-       narg = vs_top - vs_base;
-       for (i = 0, l = 0;  i < narg;  i++) {
-               vs_base[i] = coerce_to_string(vs_base[i]);
-               l += vs_base[i]->st.st_fillp;
-       }
-       v = vs_top;
-       {BEGIN_NO_INTERRUPT;    
-       vs_push(alloc_simple_string(l));
-       (*v)->st.st_self = alloc_relblock(l);
-       for (i = 0, l = 0;  i < narg;  i++)
-               for (m = 0;  m < vs_base[i]->st.st_fillp;  m++)
-                       (*v)->st.st_self[l++]
-                       = vs_base[i]->st.st_self[m];
-       vs_base[0] = *v;
-       vs_top = vs_base + 1;
-       END_NO_INTERRUPT;}      
 }
 
 void
@@ -628,6 +633,4 @@ gcl_init_string_function()
        make_function("NSTRING-CAPITALIZE", Lnstring_capitalize);
        make_function("STRING", Lstring);
 
-       make_si_function("STRING-CONCATENATE",
-                        siLstring_concatenate);
 }

diff --git a/o/unixfsys.c b/o/unixfsys.c
index 32e8ebe5bbe66547a9355faab2fcc84b31284cf7..ccf6ae66e213b3b780f07f53b7bc073f52611f84 100755 (executable)
--- a/o/unixfsys.c
+++ b/o/unixfsys.c
@@ -55,7 +55,7 @@ get_string(object x) {
     case smm_probe:
     case smm_io:
       return get_string(x->sm.sm_object1);
-    case smm_file_synonym:
+    case smm_synonym:
       return get_string(x->sm.sm_object0->s.s_dbind);
     }
   }
@@ -169,24 +169,6 @@ DEF_ORDINARY("DIRECTORY",sKdirectory,KEYWORD,"");
 DEF_ORDINARY("LINK",sKlink,KEYWORD,"");
 DEF_ORDINARY("FILE",sKfile,KEYWORD,"");
 
-object
-file_stream(object x) {
-  if (type_of(x)==t_stream)
-    switch(x->sm.sm_mode) {
-    case smm_input:
-    case smm_output:
-    case smm_io:
-    case smm_probe:
-      return x;
-    case smm_synonym:
-      return file_stream(x->sm.sm_object0->s.s_dbind);
-    default:
-      break;
-  }
-  return Cnil;
-}
-
-
 DEFUNM_NEW("STAT",object,fSstat,SI,1,1,NONE,OO,OO,OO,OO,(object x),"") {
 
   struct stat ss;

diff --git a/pcl/sys-proclaim.lisp b/pcl/sys-proclaim.lisp
index 2e1b703980e8e6106b0f776174199107ce89ca74..b36825f2deeacfcc0f4c3902ca10105f3bc879c5 100644 (file)
--- a/pcl/sys-proclaim.lisp
+++ b/pcl/sys-proclaim.lisp
@@ -2,673 +2,402 @@
 (COMMON-LISP::IN-PACKAGE "PCL") 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FUNCTION)
-         PCL::CACHE-LIMIT-FN PCL::FAST-METHOD-CALL-FUNCTION
-         PCL::METHOD-CALL-FUNCTION)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM COMMON-LISP::T)
+             COMMON-LISP::T)
+         PCL::%CCLOSURE-ENV-NTHCDR)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T)
-         PCL::DISPATCH-DFUN-INFO PCL::DEFAULT-METHOD-ONLY-DFUN-INFO
-         PCL::MAKE-CACHE PCL::BOOTSTRAP-BUILT-IN-CLASSES
-         PCL::RENEW-SYS-FILES PCL::SHOW-EMF-CALL-TRACE PCL::MAKE-CPD
-         PCL::BOOTSTRAP-META-BRAID PCL::CACHES-TO-ALLOCATE
-         PCL::LIST-ALL-DFUNS PCL::INITIAL-DISPATCH-DFUN-INFO
-         PCL::INITIAL-DFUN-INFO PCL::%%ALLOCATE-INSTANCE--CLASS
-         PCL::MAKE-ARG-INFO PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2
-         PCL::SHOW-FREE-CACHE-VECTORS PCL::UPDATE-DISPATCH-DFUNS
-         PCL::GET-EFFECTIVE-METHOD-GENSYM PCL::IN-THE-COMPILER-P
-         PCL::SHOW-DFUN-CONSTRUCTORS PCL::NO-METHODS-DFUN-INFO
-         PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
-         PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1
-         PCL::STRUCTURE-FUNCTIONS-EXIST-P)) 
+         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::FIXNUM)
+         PCL::GET-WRAPPER-CACHE-NUMBER)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) PCL::FIELD-TYPE)
-         PCL::CACHE-FIELD)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             PCL::NON-NEGATIVE-FIXNUM)
+         PCL::CACHE-NLINES PCL::CACHE-MASK PCL::CACHE-SIZE
+         PCL::CACHE-MAX-LOCATION)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T)
              COMMON-LISP::SIMPLE-VECTOR)
          PCL::CACHE-VECTOR)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             (COMMON-LISP::INTEGER 1 256))
-         PCL::CACHE-LINE-SIZE)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             (COMMON-LISP::INTEGER 1 255))
-         PCL::CACHE-NKEYS)) 
-(COMMON-LISP::MAPC
-    (COMMON-LISP::LAMBDA (COMPILER::X)
-      (COMMON-LISP::SETF
-          (COMMON-LISP::GET COMPILER::X 'SYSTEM::PROCLAIMED-CLOSURE)
-          COMMON-LISP::T))
-    '(PCL::REDEFINE-FUNCTION PCL::DO-STANDARD-DEFSETF-1
-         PCL::FDEFINE-CAREFULLY PCL::TRACE-METHOD-INTERNAL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T))
-         PCL::SYMBOL-APPEND)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
-         PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
-         PCL::GENERIC-CLOBBERS-FUNCTION PCL::STRUCTURE-SLOTD-TYPE
-         WALKER::GET-WALKER-TEMPLATE PCL::COMPILE-LAMBDA-UNCOMPILED
-         PCL::EXTRACT-LAMBDA-LIST PCL::DEFAULT-METHOD-ONLY-P
-         PCL::DISPATCH-CACHE PCL::STRUCTURE-SLOTD-NAME
-         PCL::FAST-METHOD-CALL-P PCL::SFUN-P
-         PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST
-         PCL::EARLY-CLASS-DEFINITION PCL::CONSTANT-SYMBOL-P
-         PCL::ARG-INFO-LAMBDA-LIST WALKER::ENV-LEXICAL-VARIABLES
-         PCL::INTERN-EQL-SPECIALIZER PCL::PARSE-SPECIALIZERS
-         PCL::%STD-INSTANCE-WRAPPER PCL::UPDATE-ALL-C-A-M-GF-INFO
-         PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION
-         PCL::STORE-FGEN PCL::COMPUTE-MCASE-PARAMETERS
-         PCL::INTERNED-SYMBOL-P PCL::MAKE-CALL-METHODS
-         PCL::USE-CACHING-DFUN-P PCL::LEGAL-CLASS-NAME-P
-         WALKER::VARIABLE-GLOBALLY-SPECIAL-P PCL::FUNCTION-RETURNING-T
-         PCL::METHOD-FUNCTION-METHOD PCL::GET-BUILT-IN-CLASS-SYMBOL
-         PCL::DEFAULT-STRUCTURE-TYPE PCL::GF-DFUN-INFO PCL::CACHING-P
-         PCL::FREE-CACHE-VECTOR PCL::ONE-CLASS-CACHE
-         PCL::DEFAULT-TEST-CONVERTER PCL::UNDEFMETHOD-1
-         PCL::MAKE-INITFUNCTION PCL::GET-CACHE-VECTOR
-         PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::GF-INFO-FAST-MF-P
-         PCL::ECD-SOURCE PCL::INITIAL-P PCL::ARG-INFO-APPLYP
-         PCL::ARG-INFO-KEYWORDS
-         PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION
-         PCL::CACHING-DFUN-COST PCL::INITIAL-DISPATCH-P PCL::EVAL-FORM
-         PCL::MAKE-CONSTANT-FUNCTION PCL::FUNCTION-RETURNING-NIL
-         PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::FGEN-GENSYMS
-         PCL::EXPAND-SHORT-DEFCOMBIN WALKER::ENV-LOCK
-         PCL::INITIALIZE-INFO-CACHED-CONSTANTS
-         PCL::INITIALIZE-INFO-WRAPPER
-         PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME PCL::TWO-CLASS-INDEX
-         PCL::ONE-INDEX-ACCESSOR-TYPE
-         PCL::EARLY-COLLECT-DEFAULT-INITARGS WALKER::ENV-WALK-FORM
-         PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS PCL::MAKE-FUNCTION-INLINE
-         PCL::FLUSH-CACHE-VECTOR-INTERNAL
-         PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION
-         PCL::FGEN-GENERATOR PCL::CONSTANT-VALUE-P
-         PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
-         PCL::EARLY-CLASS-PRECEDENCE-LIST PCL::SLOT-BOUNDP-SYMBOL
-         PCL::ARG-INFO-NUMBER-OPTIONAL
-         PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::GET-PV-CELL-FOR-CLASS
-         PCL::CHECKING-FUNCTION PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P
-         PCL::INITIAL-DISPATCH-CACHE PCL::STRUCTURE-SVUC-METHOD
-         PCL::NO-METHODS-CACHE PCL::GF-DFUN-CACHE PCL::%CCLOSURE-ENV
-         PCL::CONSTANT-VALUE-CACHE PCL::BUILT-IN-WRAPPER-OF
-         PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P
-         PCL::EARLY-COLLECT-CPL COMMON-LISP::CLASS-OF
-         PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL PCL::SYMBOL-PKG-NAME
-         PCL::GDEFINITION
-         PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION
-         PCL::ACCESSOR-DFUN-INFO-CACHE PCL::EXTRACT-SPECIALIZER-NAMES
-         PCL::CHECK-WRAPPER-VALIDITY PCL::MAKE-INITIAL-DFUN
-         PCL::WRAPPER-FIELD PCL::EARLY-SLOT-DEFINITION-LOCATION
-         PCL::EARLY-GF-P PCL::GF-INFO-STATIC-C-A-M-EMF PCL::LOOKUP-FGEN
-         PCL::MAKE-PV-TYPE-DECLARATION
-         PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS
-         PCL::EARLY-METHOD-CLASS
-         PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION
-         WALKER::ENV-DECLARATIONS PCL::ALLOCATE-CACHE-VECTOR
-         PCL::FUNCTION-PRETTY-ARGLIST
-         PCL::EARLY-CLASS-DIRECT-SUBCLASSES
-         PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P
-         PCL::MAKE-CLASS-EQ-PREDICATE PCL::ECD-OTHER-INITARGS
-         PCL::GBOUNDP PCL::METHOD-FUNCTION-PV-TABLE
-         WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
-         PCL::MAKE-INSTANCE-FUNCTION-SYMBOL
-         PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-         PCL::FIND-CYCLE-REASONS PCL::FGEN-TEST
-         PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD PCL::FREE-CACHE
-         PCL::TYPE-CLASS PCL::INITIAL-CACHE
-         PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS
-         PCL::STRUCTURE-SLOTD-WRITER-FUNCTION
-         PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION
-         PCL::EARLY-COLLECT-SLOTS PCL::LIST-DFUN
-         PCL::EXPAND-MAKE-INSTANCE-FORM PCL::N-N-CACHE
-         PCL::MAKE-TYPE-PREDICATE PCL::INTERN-FUNCTION-NAME
-         PCL::GET-MAKE-INSTANCE-FUNCTIONS WALKER::ENV-WALK-FUNCTION
-         PCL::TWO-CLASS-CACHE PCL::MAKE-CALLS-TYPE-DECLARATION
-         PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
-         PCL::INITIALIZE-INFO-KEY PCL::GF-LAMBDA-LIST
-         ITERATE::VARIABLES-FROM-LET PCL::COMPUTE-CLASS-SLOTS
-         PCL::DFUN-ARG-SYMBOL PCL::CHECKING-P PCL::ARG-INFO-P
-         PCL::INITIALIZE-INFO-CACHED-RI-VALID-P PCL::CHECKING-CACHE
-         PCL::METHOD-FUNCTION-PLIST PCL::STRUCTURE-OBJECT-P
-         PCL::ARG-INFO-PRECEDENCE PCL::ONE-CLASS-INDEX
-         PCL::STD-INSTANCE-P PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST
-         PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-         PCL::EARLY-SLOT-DEFINITION-NAME PCL::UNPARSE-SPECIALIZERS
-         PCL::STRUCTURE-TYPE-P PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE
-         PCL::PV-TABLEP PCL::CLASS-FROM-TYPE
-         PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE PCL::STRUCTURE-TYPE
-         PCL::MAKE-EQL-PREDICATE PCL::TWO-CLASS-ACCESSOR-TYPE
-         PCL::DEFAULT-STRUCTURE-INSTANCE-P
-         PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME
-         PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE PCL::GFS-OF-TYPE
-         PCL::DEFAULT-STRUCTUREP PCL::EARLY-CLASS-NAME-OF
-         PCL::%STD-INSTANCE-SLOTS PCL::ONE-INDEX-INDEX PCL::WRAPPER-OF
-         PCL::ARG-INFO-VALID-P PCL::KEYWORD-SPEC-NAME
-         PCL::METHOD-CALL-P PCL::SHOW-DFUN-COSTS PCL::DFUN-INFO-CACHE
-         PCL::DEFAULT-CONSTANT-CONVERTER ITERATE::SEQUENCE-ACCESSOR
-         PCL::COUNT-DFUN PCL::EXPAND-LONG-DEFCOMBIN
-         PCL::CACHING-DFUN-INFO PCL::INITIALIZE-INFO-CACHED-VALID-P
-         PCL::FAST-INSTANCE-BOUNDP-P PCL::ARG-INFO-METATYPES
-         PCL::EXTRACT-PARAMETERS PCL::GF-INFO-C-A-M-EMF-STD-P
-         PCL::FINAL-ACCESSOR-DFUN-TYPE PCL::GMAKUNBOUND
-         PCL::FAST-METHOD-CALL-ARG-INFO PCL::COMPUTE-LINE-SIZE
-         PCL::ONE-INDEX-CACHE PCL::NO-METHODS-P
-         PCL::COMPUTE-STD-CPL-PHASE-2
-         PCL::COMPLICATED-INSTANCE-CREATION-METHOD
-         PCL::MAKE-PERMUTATION-VECTOR PCL::CONSTANT-VALUE-DFUN-INFO
-         PCL::TWO-CLASS-WRAPPER1 PCL::MAP-ALL-GENERIC-FUNCTIONS
-         PCL::CLASS-PREDICATE SYSTEM::%STRUCTURE-NAME
-         PCL::RESET-CLASS-INITIALIZE-INFO
-         PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 PCL::EARLY-CLASS-NAME
-         PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
-         PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::SLOT-READER-SYMBOL
-         PCL::ARG-INFO-NKEYS PCL::METHOD-CALL-CALL-METHOD-ARGS
-         PCL::CCLOSUREP PCL::DEFAULT-METHOD-ONLY-CACHE
-         PCL::NEXT-WRAPPER-FIELD PCL::SLOT-WRITER-SYMBOL
-         PCL::ACCESSOR-DFUN-INFO-P
-         PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
-         PCL::EXTRACT-REQUIRED-PARAMETERS PCL::FORMAT-CYCLE-REASONS
-         PCL::UNENCAPSULATED-FDEFINITION
-         PCL::GET-BUILT-IN-WRAPPER-SYMBOL PCL::ONE-CLASS-P
-         PCL::ECD-METACLASS PCL::METHOD-LL->GENERIC-FUNCTION-LL
-         PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES PCL::ONE-INDEX-P
-         PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
-         PCL::ECD-CANONICAL-SLOTS
-         PCL::METHOD-FUNCTION-NEEDS-NEXT-METHODS-P
-         PCL::INITIALIZE-INFO-CACHED-NEW-KEYS
-         PCL::STRUCTURE-SLOTD-READER-FUNCTION
-         PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
-         PCL::DISPATCH-P PCL::LIST-LARGE-CACHE
-         PCL::FAST-METHOD-CALL-PV-CELL PCL::GET-MAKE-INSTANCE-FUNCTION
-         PCL::DNET-METHODS-P PCL::STRUCTURE-SLOTD-INIT-FORM
-         PCL::UPDATE-CLASS-CAN-PRECEDE-P PCL::ONE-CLASS-ACCESSOR-TYPE
-         PCL::RESET-INITIALIZE-INFO PCL::STANDARD-SVUC-METHOD
-         PCL::DEFAULT-CONSTANTP PCL::UPDATE-C-A-M-GF-INFO
-         PCL::ONE-INDEX-DFUN-INFO-CACHE PCL::EARLY-CLASS-SLOTS
-         PCL::CPD-SUPERS PCL::FGEN-GENERATOR-LAMBDA
-         PCL::ECD-SUPERCLASS-NAMES PCL::ECD-CLASS-NAME PCL::SETFBOUNDP
-         PCL::GET-SETF-FUNCTION-NAME PCL::DFUN-INFO-P
-         PCL::SLOT-VECTOR-SYMBOL PCL::INITIALIZE-INFO-P
-         PCL::TWO-CLASS-P PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE
-         PCL::COPY-CACHE PCL::MAKE-PV-TABLE-TYPE-DECLARATION
-         PCL::SORT-CALLS PCL::STRUCTURE-SLOT-BOUNDP PCL::%FBOUNDP
-         PCL::RESET-CLASS-INITIALIZE-INFO-1 PCL::UPDATE-GF-INFO
-         PCL::WRAPPER-FOR-STRUCTURE PCL::FUNCALLABLE-INSTANCE-P
-         PCL::CPD-CLASS PCL::EARLY-METHOD-STANDARD-ACCESSOR-P
-         PCL::SORT-SLOTS PCL::CANONICAL-SLOT-NAME
-         PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
-         PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::%SYMBOL-FUNCTION
-         PCL::EARLY-METHOD-LAMBDA-LIST PCL::ONE-INDEX-DFUN-INFO-INDEX
-         PCL::N-N-ACCESSOR-TYPE PCL::CACHING-CACHE
-         PCL::EARLY-CLASS-SLOTDS PCL::ONE-INDEX-DFUN-INFO-P
-         SYSTEM::%COMPILED-FUNCTION-NAME
-         PCL::BOOTSTRAP-CLASS-PREDICATES PCL::NET-TEST-CONVERTER
-         PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS PCL::TWO-CLASS-WRAPPER0
-         PCL::MAP-SPECIALIZERS PCL::EARLY-GF-NAME PCL::N-N-P
-         PCL::FGEN-SYSTEM PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P
-         PCL::UPDATE-GFS-OF-CLASS PCL::ONE-CLASS-WRAPPER0
-         PCL::CPD-AFTER
-         PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION
-         PCL::CACHE-P PCL::EARLY-METHOD-QUALIFIERS PCL::CHECK-CACHE
-         PCL::FORCE-CACHE-FLUSHES PCL::CACHE-OWNER
-         PCL::COMPILE-LAMBDA-DEFERRED PCL::ARG-INFO-KEY/REST-P)) 
-(COMMON-LISP::PROCLAIM
-    '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*)
-         COMMON-LISP::INVALID-METHOD-ERROR PCL::LIST-LARGE-CACHES
-         PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE PCL::UNTRACE-METHOD
-         COMMON-LISP::METHOD-COMBINATION-ERROR)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         PCL::ACCESSOR-VALUES-INTERNAL
+         PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
+         PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
+         PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN
+         PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
+         PCL::CHECK-METHOD-ARG-INFO
+         PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|
+         PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
+         PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+         PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
+         PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
+         PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P
+         ITERATE::WALK-GATHERING-BODY
+         PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER
+         PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
+         PCL::SLOT-BOUNDP-USING-CLASS-DFUN WALKER::WALK-FORM-INTERNAL
+         PCL::LOAD-LONG-DEFCOMBIN PCL::MAKE-FINAL-CACHING-DFUN
+         PCL::EMIT-READER/WRITER
+         PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION
+         PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS
+         PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
+         PCL::EMIT-READER/WRITER-FUNCTION PCL::ACCESSOR-VALUES1
+         PCL::GENERATING-LISP PCL::GET-CLASS-SLOT-VALUE-1
+         PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN PCL::CACHE-MISS-VALUES
+         WALKER::WALK-LET-IF
+         PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
+         PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
+         PCL::CHECKING-MISS ITERATE::EXPAND-INTO-LET
+         PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
+         PCL::CONSTANT-VALUE-MISS ITERATE::RENAME-VARIABLES
+         PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|
+         PCL::SET-SLOT-VALUE
+         PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
+         PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|
+         PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|
+         PCL::CONVERT-METHODS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             PCL::NON-NEGATIVE-FIXNUM)
-         PCL::CACHE-MAX-LOCATION PCL::CACHE-NLINES PCL::CACHE-SIZE
-         PCL::CACHE-MASK)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
+         PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|
+         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+         PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
+         PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
+         PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN
+         PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
+         PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+         PCL::ADD-METHOD-DECLARATIONS
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+         PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+         PCL::WALK-METHOD-LAMBDA
+         PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION
-         ITERATE::SIMPLE-EXPAND-ITERATE-FORM PCL::ADD-DIRECT-SUBCLASSES
-         PCL::PROCLAIM-DEFMETHOD PCL::UPDATE-INITIALIZE-INFO-INTERNAL
-         PCL::RAISE-METATYPE PCL::CLASS-CAN-PRECEDE-P
-         WALKER::VARIABLE-SPECIAL-P PCL::GF-MAKE-FUNCTION-FROM-EMF
-         PCL::|SETF PCL METHOD-FUNCTION-PLIST|
-         PCL::SET-FUNCTION-PRETTY-ARGLIST
-         PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS
-         PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST
-         PCL::DEAL-WITH-ARGUMENTS-OPTION WALKER::NOTE-DECLARATION
-         PCL::MAKE-CLASS-PREDICATE PCL::VALUE-FOR-CACHING
-         PCL::EMIT-1-NIL-DLAP PCL::MAKE-CAXR PCL::SYMBOL-LESSP
-         PCL::GET-KEY-ARG1 PCL::ADD-FORMS
-         PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
-         PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER
-         PCL::CLASSES-HAVE-COMMON-SUBCLASS-P PCL::N-N-DFUN-INFO
-         PCL::CANONICALIZE-SLOT-SPECIFICATION
-         PCL::REDIRECT-EARLY-FUNCTION-INTERNAL
-         PCL::UPDATE-STD-OR-STR-METHODS PCL::%SET-CCLOSURE-ENV
-         PCL::QUALIFIER-CHECK-RUNTIME
-         PCL::MAKE-STD-READER-METHOD-FUNCTION 
-         PCL::ADD-SLOT-ACCESSORS PCL::ADD-TO-CVECTOR
-         PCL::COMPUTE-LAYOUT PCL::DESTRUCTURE-INTERNAL
-         PCL::SUPERCLASSES-COMPATIBLE-P
-         PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION ITERATE::MV-SETQ
-         PCL::COMPUTE-STD-CPL PCL::SET-METHODS PCL::CHECKING-DFUN-INFO
-         ITERATE::EXTRACT-SPECIAL-BINDINGS PCL::SWAP-WRAPPERS-AND-SLOTS
-         PCL::CANONICALIZE-DEFCLASS-OPTION PCL::MAKE-CDXR
-         PCL::PRINTING-RANDOM-THING-INTERNAL COMMON-LISP::ADD-METHOD
-         PCL::STANDARD-INSTANCE-ACCESS
-         SYSTEM::%SET-COMPILED-FUNCTION-NAME PCL::FIND-SLOT-DEFINITION
-         PCL::CLASS-MIGHT-PRECEDE-P
-         PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION PCL::SAUT-NOT-EQL
-         PCL::SET-WRAPPER PCL::SET-STANDARD-SVUC-METHOD
-         PCL::SAUT-NOT-PROTOTYPE PCL::ACCESSOR-MISS-FUNCTION
-         PCL::NO-SLOT PCL::REMTAIL PCL::PV-WRAPPERS-FROM-ALL-ARGS
-         PCL::UPDATE-CLASS PCL::AUGMENT-TYPE PCL::MAKE-EARLY-ACCESSOR
-         PCL::MAKE-PLIST PCL::MEC-ALL-CLASSES-INTERNAL
-         PCL::MAKE-STD-WRITER-METHOD-FUNCTION
-         PCL::PARSE-QUALIFIER-PATTERN PCL::MEMF-CONSTANT-CONVERTER
-         PCL::|SETF PCL FIND-CLASS-PREDICATE|
-         PCL::MAKE-UNORDERED-METHODS-EMF WALKER::ENVIRONMENT-FUNCTION
-         PCL::MEC-ALL-CLASS-LISTS PCL::SAUT-NOT-CLASS-EQ
-         PCL::DO-SATISFIES-DEFTYPE PCL::SET-STRUCTURE-SVUC-METHOD
-         PCL::MAKE-DLAP-LAMBDA-LIST PCL::METHOD-FUNCTION-RETURNING-T
-         PCL::COMPUTE-CALLS PCL::REMOVE-SLOT-ACCESSORS
-         PCL::UPDATE-ALL-PV-TABLE-CACHES PCL::MAKE-DFUN-LAMBDA-LIST
-         WALKER::NOTE-LEXICAL-BINDING PCL::REMOVE-DIRECT-SUBCLASSES
-         PCL::MAP-PV-TABLE-REFERENCES-OF PCL::COMPUTE-CONSTANTS
-         PCL::METHOD-FUNCTION-RETURNING-NIL PCL::METHODS-CONVERTER
-         PCL::PV-TABLE-LOOKUP PCL::DESCRIBE-PACKAGE
-         COMMON-LISP::SLOT-EXISTS-P PCL::MAKE-PV-TABLE-INTERNAL
-         PCL::SAUT-NOT-CLASS PCL::|SETF PCL FIND-CLASS|
-         PCL::UPDATE-INITS PCL::UPDATE-CPL
-         PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
-         PCL::COMPUTE-PV WALKER::VARIABLE-LEXICAL-P
-         PCL::PROCLAIM-DEFGENERIC PCL::MAKE-DFUN-ARG-LIST
-         PCL::GET-KEY-ARG COMMON-LISP::REMOVE-METHOD
-         PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS PCL::VARIABLE-CLASS
-         PCL::UPDATE-SLOTS PCL::SYMBOL-OR-CONS-LESSP
-         PCL::MEC-ALL-CLASSES PCL::LIST-EQ
-         PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION
-         WALKER::WALK-REPEAT-EVAL WALKER::ENVIRONMENT-MACRO
-         WALKER::VARIABLE-SYMBOL-MACRO-P
-         PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
-         PCL::BOOTSTRAP-SLOT-INDEX PCL::PLIST-VALUE
-         PCL::CHANGE-CLASS-INTERNAL PCL::NET-CONSTANT-CONVERTER
-         PCL::|SETF PCL GDEFINITION| PCL::FIND-STANDARD-II-METHOD)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
+             COMMON-LISP::*)
+         PCL::GET-ACCESSOR-METHOD-FUNCTION
+         PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
+         PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN
+         PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
+         PCL::GENERATE-DISCRIMINATION-NET
+         PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+         PCL::LOAD-SHORT-DEFCOMBIN
+         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
+         PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+         PCL::REAL-MAKE-METHOD-LAMBDA PCL::SET-CLASS-SLOT-VALUE-1
+         PCL::BOOTSTRAP-ACCESSOR-DEFINITION
+         PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN
+         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
+         PCL::ACCESSOR-MISS PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|
+         PCL::ACCESSOR-VALUES
+         PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
+         PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))|
+         PCL::EMIT-CHECKING-OR-CACHING-FUNCTION
+         PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION
+         PCL::MAKE-FINAL-CHECKING-DFUN
+         PCL::MAKE-SHARED-INITIALIZE-FORM-LIST
+         PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
+         PCL::EMIT-CHECKING-OR-CACHING
+         PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|
+         PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+         PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
+         PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
+         PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN
+         PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
+         PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|
+         PCL::ORDER-SPECIALIZERS
+         PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
+         PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::*)
-         WALKER::WALK-FORM PCL::MAKE-INSTANCE-1
-         PCL::EXTRACT-DECLARATIONS PCL::GET-FUNCTION
-         WALKER::MACROEXPAND-ALL PCL::ALLOCATE-STRUCTURE-INSTANCE
-         PCL::MAKE-FINAL-DFUN-INTERNAL PCL::GET-METHOD-FUNCTION
-         PCL::COERCE-TO-CLASS PCL::MAP-ALL-CLASSES PCL::ENSURE-CLASS
-         PCL::PARSE-METHOD-OR-SPEC COMMON-LISP::ENSURE-GENERIC-FUNCTION
-         PCL::MAKE-CACHING-DFUN PCL::GET-FUNCTION1
-         PCL::GET-DFUN-CONSTRUCTOR PCL::MAKE-CONSTANT-VALUE-DFUN
-         PCL::MAKE-METHOD-FUNCTION-INTERNAL PCL::COMPILE-LAMBDA
-         PCL::PARSE-SPECIALIZED-LAMBDA-LIST PCL::DISPATCH-DFUN-COST
-         PCL::MAKE-METHOD-LAMBDA-INTERNAL)) 
+         PCL::MAKE-N-N-ACCESSOR-DFUN
+         PCL::GET-SIMPLE-INITIALIZATION-FUNCTION
+         PCL::MAKE-FINAL-ACCESSOR-DFUN
+         PCL::GET-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-ACCESSOR-TABLE
+         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION PCL::MAKE-CHECKING-DFUN
+         PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS
+         PCL::MAKE-DEFAULT-INITARGS-FORM-LIST PCL::REAL-ADD-METHOD
+         PCL::SLOT-VALUE-OR-DEFAULT PCL::LOAD-DEFGENERIC PCL::CPL-ERROR
+         WALKER::NESTED-WALK-FORM PCL::TYPES-FROM-ARGUMENTS
+         PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
-             (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T))
-         PCL::MAKE-CLASS-PREDICATE-NAME PCL::MAKE-KEYWORD)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION
+         PCL::GENERATE-DISCRIMINATION-NET-INTERNAL
+         PCL::CACHE-MISS-VALUES-INTERNAL
+         PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::DO-SHORT-METHOD-COMBINATION PCL::MEMF-CODE-CONVERTER)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::T)
-         PCL::FIND-CLASS-FROM-CELL PCL::GET-METHOD-FUNCTION-PV-CELL
-         PCL::PROBE-CACHE PCL::NAMED-OBJECT-PRINT-FUNCTION
-         PCL::PRECOMPUTE-EFFECTIVE-METHODS
-         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE
-         PCL::GET-EFFECTIVE-METHOD-FUNCTION1 PCL::MAKE-EMF-FROM-METHOD
-         PCL::EMIT-MISS PCL::REAL-ENSURE-GF-USING-CLASS--NULL
-         PCL::RECORD-DEFINITION WALKER::CONVERT-MACRO-TO-LAMBDA
-         PCL::INITIALIZE-INFO PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION
-         PCL::METHOD-FUNCTION-GET PCL::FIND-CLASS-PREDICATE-FROM-CELL
-         PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS
-         PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1 PCL::GET-DECLARATION
-         PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
-         PCL::MAP-CACHE)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::*)
+             COMMON-LISP::*)
+         PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN WALKER::WALK-DECLARATIONS
+         PCL::GET-SECONDARY-DISPATCH-FUNCTION)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
                  COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
-         PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-         PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
-         WALKER::WALK-PROG/PROG*
-         PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
-         WALKER::WALK-BINDINGS-2
-         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
-         WALKER::WALK-DO/DO*
-         PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-         PCL::|(FAST-METHOD DOCUMENTATION (T))|
-         PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))|
-         PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-         PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
-         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
-         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
-         PCL::INITIALIZE-INSTANCE-SIMPLE PCL::BOOTSTRAP-SET-SLOT
-         PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
-         PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
-         PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-         PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
-         PCL::FILL-CACHE-P
-         PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
-         PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|
-         PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
-         PCL::OPTIMIZE-WRITER PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE
-         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL
-         PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
-         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1
-         PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
-         PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
-         PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
-         PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
-         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
-         PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
-         PCL::ADJUST-CACHE
-         PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
-         PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
-         PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
-         PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
-         PCL::MEMF-TEST-CONVERTER
-         PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
-         PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
-         WALKER::WALK-TEMPLATE PCL::TWO-CLASS-DFUN-INFO
-         PCL::EXPAND-CACHE
-         PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
-         PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
-         PCL::GET-WRAPPERS-FROM-CLASSES
-         PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
-         PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-         PCL::LOAD-PRECOMPILED-IIS-ENTRY
-         PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
-         PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
-         PCL::MAYBE-EXPAND-ACCESSOR-FORM
-         PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY
-         PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
-         PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
-         PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|
-         PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
-         PCL::EXPAND-DEFCLASS
-         PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
-         WALKER::WALK-LET/LET* PCL::MAKE-DISPATCH-LAMBDA
-         PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|
-         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
-         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
-         PCL::OPTIMIZE-READER
-         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
-         PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-         PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|)) 
+             COMMON-LISP::*)
+         PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|
+         PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
+         ITERATE::ITERATE-TRANSFORM-BODY)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::OPTIMIZE-SET-SLOT-VALUE
-         PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
-         PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
-         PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-         PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
-         PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|
-         PCL::PRINT-CACHE WALKER::WALK-UNEXPECTED-DECLARE
-         ITERATE::OPTIMIZE-ITERATE-FORM
-         PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|
-         WALKER::WALK-MULTIPLE-VALUE-SETQ PCL::FIRST-FORM-TO-LISP
-         PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
-         WALKER::WALK-LABELS
-         PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
-         PCL::ONE-CLASS-DFUN-INFO PCL::GET-FUNCTION-GENERATOR
-         WALKER::RELIST-INTERNAL PCL::NOTE-PV-TABLE-REFERENCE
-         WALKER::WALK-LAMBDA PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS
-         PCL::ONE-INDEX-DFUN-INFO PCL::MAP-ALL-ORDERS
-         PCL::OPTIMIZE-GF-CALL-INTERNAL PCL::COMPUTE-PRECEDENCE
-         WALKER::WALK-DO PCL::PRINT-STD-INSTANCE
-         PCL::OBSOLETE-INSTANCE-TRAP PCL::SORT-APPLICABLE-METHODS
-         PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
-         PCL::EMIT-GREATER-THAN-1-DLAP
-         PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
-         WALKER::WALK-FLET
-         PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
-         PCL::|SETF PCL PLIST-VALUE| WALKER::WALK-PROG*
-         WALKER::VARIABLE-DECLARATION
-         PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
-         PCL::SKIP-FAST-SLOT-ACCESS-P PCL::SET-FUNCTION-NAME-1
-         WALKER::WALK-MACROLET PCL::CAN-OPTIMIZE-ACCESS
-         WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
-         PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
-         PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
-         PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
-         PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P
-         PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
-         PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|
-         PCL::EMIT-BOUNDP-CHECK PCL::|SETF PCL METHOD-FUNCTION-GET|
-         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
-         PCL::MAKE-METHOD-SPEC PCL::FLUSH-CACHE-TRAP WALKER::WALK-IF
-         PCL::OPTIMIZE-SLOT-BOUNDP
-         PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD
-         WALKER::WALK-MULTIPLE-VALUE-BIND
-         ITERATE::RENAME-AND-CAPTURE-VARIABLES WALKER::WALK-LET*
-         WALKER::WALK-DO*
-         PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
-         PCL::INVALIDATE-WRAPPER
-         PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
-         PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
-         PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
-         ITERATE::SIMPLE-EXPAND-GATHERING-FORM PCL::ENTRY-IN-CACHE-P
-         WALKER::WALK-LOCALLY PCL::OPTIMIZE-SLOT-VALUE
-         PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
-         PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))|
-         PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
-         PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|
-         PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
-         PCL::TRACE-EMF-CALL-INTERNAL WALKER::WALK-SYMBOL-MACROLET
-         PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
-         PCL::CONVERT-TABLE
-         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
-         PCL::INITIALIZE-INTERNAL-SLOT-GFS*
-         PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
-         PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|
-         PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
-         PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
-         PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
-         PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
-         WALKER::WALK-SETQ PCL::EXPAND-DEFGENERIC
-         PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
-         ITERATE::OPTIMIZE-GATHERING-FORM PCL::FIX-SLOT-ACCESSORS
-         PCL::EMIT-SLOT-READ-FORM WALKER::WALK-PROG
-         PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
-         WALKER::WALK-NAMED-LAMBDA PCL::GET-NEW-FUNCTION-GENERATOR
-         PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))|
-         WALKER::WALK-TAGBODY
-         PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))|
-         WALKER::WALK-COMPILER-LET PCL::DECLARE-STRUCTURE
-         WALKER::WALK-LET ITERATE::VARIABLE-SAME-P
-         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
-         PCL::EMIT-1-T-DLAP PCL::MAKE-DFUN-CALL
-         PCL::COMPUTE-EFFECTIVE-METHOD PCL::SORT-METHODS
-         WALKER::WALK-TAGBODY-1
-         PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
-         PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
-         PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
-         PCL::MAKE-TOP-LEVEL-FORM
-         PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
-         WALKER::RECONS)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::*)
+         ITERATE::RENAME-LET-BINDINGS
+         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::UPDATE-SLOTS-IN-PV PCL::MAKE-INSTANCE-FUNCTION-COMPLEX
-         PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL
-         PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
-         PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
-         PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
-         PCL::COMPUTE-PV-SLOT PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1
-         PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
-         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
-         PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))|
-         PCL::OPTIMIZE-INSTANCE-ACCESS
-         PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
-         PCL::REAL-MAKE-METHOD-INITARGS-FORM
-         PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T))|
-         PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
-         PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL
-         PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS
-         PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|
-         PCL::MAKE-PARAMETER-REFERENCES
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
-         PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::OPTIMIZE-ACCESSOR-CALL
-         WALKER::WALK-TEMPLATE-HANDLE-REPEAT WALKER::WALK-BINDINGS-1
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
-         PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1
-         PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::MAKE-FGEN
-         PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
-         PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
-         PCL::OPTIMIZE-GENERIC-FUNCTION-CALL
-         PCL::LOAD-FUNCTION-GENERATOR PCL::MAKE-EMF-CACHE
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
-         PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::EXPAND-EMF-CALL-METHOD)) 
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::*)
+             COMMON-LISP::*)
+         PCL::REAL-MAKE-A-METHOD)) 
+(COMMON-LISP::MAPC
+    (COMMON-LISP::LAMBDA (COMPILER::X)
+      (COMMON-LISP::SETF
+          (COMMON-LISP::GET COMPILER::X 'COMPILER::PROCLAIMED-CLOSURE)
+          COMMON-LISP::T))
+    '(PCL::REDEFINE-FUNCTION PCL::DO-STANDARD-DEFSETF-1
+         PCL::TRACE-METHOD-INTERNAL PCL::FDEFINE-CAREFULLY)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*)
+         PCL::ANALYZE-LAMBDA-LIST PCL::GET-DISPATCH-FUNCTION
+         PCL::PARSE-DEFMETHOD PCL::MAKE-DISPATCH-DFUN
+         PCL::EMIT-IN-CHECKING-CACHE-P PCL::EMIT-ONE-INDEX-READERS
+         PCL::METHOD-PROTOTYPE-FOR-GF PCL::EMIT-ONE-CLASS-READER
+         PCL::GENERIC-FUNCTION-NAME-P PCL::DEFAULT-CODE-CONVERTER
+         PCL::CLASS-EQ-TYPE PCL::CONVERT-TO-SYSTEM-TYPE
+         PCL::COMPILE-IIS-FUNCTIONS PCL::EMIT-CONSTANT-VALUE
+         PCL::GET-GENERIC-FUNCTION-INFO PCL::EARLY-METHOD-FUNCTION
+         PCL::FIND-STRUCTURE-CLASS PCL::PCL-DESCRIBE
+         PCL::NET-CODE-CONVERTER PCL::PARSE-METHOD-GROUP-SPECIFIER
+         PCL::TYPE-FROM-SPECIALIZER PCL::EMIT-TWO-CLASS-WRITER
+         PCL::COMPUTE-APPLICABLE-METHODS-EMF PCL::EMIT-ONE-CLASS-WRITER
+         PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA
+         PCL::SPECIALIZER-FROM-TYPE PCL::EARLY-COLLECT-INHERITANCE
+         PCL::EMIT-TWO-CLASS-READER PCL::FIND-WRAPPER
+         PCL::*NORMALIZE-TYPE PCL::EMIT-ONE-INDEX-WRITERS
+         PCL::STRUCTURE-WRAPPER PCL::MAKE-FINAL-DISPATCH-DFUN)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::EXPAND-DEFMETHOD PCL::LOAD-DEFMETHOD-INTERNAL)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T)
+         PCL::|__si::MAKE-INITIAL| PCL::|__si::MAKE-ARG-INFO|
+         PCL::STRING-APPEND PCL::|__si::MAKE-ONE-INDEX|
+         PCL::MAKE-INITIALIZE-INFO PCL::MAKE-FAST-METHOD-CALL
+         PCL::|__si::MAKE-STD-INSTANCE|
+         PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|
+         PCL::|__si::MAKE-CONSTANT-VALUE| PCL::|__si::MAKE-N-N|
+         PCL::FIX-EARLY-GENERIC-FUNCTIONS PCL::INTERN-PV-TABLE
+         PCL::FALSE PCL::|__si::MAKE-DFUN-INFO|
+         PCL::|__si::MAKE-CACHING| PCL::MAKE-PV-TABLE
+         PCL::MAKE-METHOD-CALL PCL::TRUE PCL::MAKE-PROGN
+         PCL::|__si::MAKE-CACHE|
+         PCL::|STRUCTURE-OBJECT class constructor|
+         PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|
+         PCL::|__si::MAKE-NO-METHODS| PCL::|__si::MAKE-ONE-CLASS|
+         PCL::|__si::MAKE-PV-TABLE| PCL::PV-WRAPPERS-FROM-PV-ARGS
+         WALKER::UNBOUND-LEXICAL-FUNCTION PCL::|__si::MAKE-TWO-CLASS|
+         PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|
+         PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|
+         PCL::MAKE-FAST-INSTANCE-BOUNDP
+         PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::USE-PACKAGE-PCL
+         PCL::|__si::MAKE-CHECKING| PCL::|__si::MAKE-INITIAL-DISPATCH|
+         PCL::|__si::MAKE-DISPATCH|)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
-             COMMON-LISP::T)
-         PCL::FILL-CACHE PCL::CAN-OPTIMIZE-ACCESS1 PCL::MAKE-EMF-CALL
-         PCL::EMIT-FETCH-WRAPPER PCL::CHECK-INITARGS-2-LIST
-         PCL::GET-METHOD PCL::CHECK-INITARGS-2-PLIST
-         PCL::CHECK-INITARGS-1 PCL::REAL-GET-METHOD
-         WALKER::WALK-ARGLIST)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FUNCTION)
+         PCL::METHOD-CALL-FUNCTION PCL::FAST-METHOD-CALL-FUNCTION
+         PCL::CACHE-LIMIT-FN)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::BOOLEAN)
+         PCL::CACHE-VALUEP)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
-             COMMON-LISP::T)
-         PCL::LOAD-DEFMETHOD PCL::MAKE-DEFMETHOD-FORM
-         PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM-INTERNAL)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             (COMMON-LISP::INTEGER 1 255))
+         PCL::CACHE-NKEYS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::T)
-         PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::SET-ARG-INFO1 PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION
-         PCL::LOAD-DEFCLASS PCL::REAL-LOAD-DEFCLASS
-         PCL::OPTIMIZE-GF-CALL WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1
-         PCL::EMIT-SLOT-ACCESS PCL::MAKE-EARLY-CLASS-DEFINITION)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             (COMMON-LISP::INTEGER 1 256))
+         PCL::CACHE-LINE-SIZE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::T)
-         PCL::EMIT-DLAP PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+             (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T))
+         PCL::SYMBOL-APPEND)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::T)
-         PCL::EARLY-ADD-NAMED-METHOD PCL::FILL-DFUN-CACHE
-         PCL::REAL-ADD-NAMED-METHOD)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             (COMMON-LISP::*))
+         PCL::SORT-APPLICABLE-METHODS PCL::SORT-METHODS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
              COMMON-LISP::T)
-         PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
+         PCL::COMPUTE-CALLS PCL::SET-STRUCTURE-SVUC-METHOD
+         PCL::UPDATE-STD-OR-STR-METHODS PCL::SET-METHODS
+         WALKER::NOTE-LEXICAL-BINDING
+         ITERATE::SIMPLE-EXPAND-ITERATE-FORM
+         PCL::|SETF PCL METHOD-FUNCTION-PLIST| PCL::SAUT-NOT-PROTOTYPE
+         PCL::VALUE-FOR-CACHING PCL::PROCLAIM-DEFMETHOD
+         PCL::MAKE-FAST-METHOD-CALL-LAMBDA-LIST
+         PCL::MAKE-STD-BOUNDP-METHOD-FUNCTION PCL::METHODS-CONVERTER
+         PCL::DEAL-WITH-ARGUMENTS-OPTION
+         PCL::UPDATE-ALL-PV-TABLE-CACHES
+         PCL::MAP-PV-TABLE-REFERENCES-OF PCL::UPDATE-CLASS
+         PCL::FIND-STANDARD-II-METHOD
+         PCL::METHOD-FUNCTION-RETURNING-NIL
+         PCL::REDIRECT-EARLY-FUNCTION-INTERNAL PCL::UPDATE-CPL
+         PCL::QUALIFIER-CHECK-RUNTIME PCL::COMPUTE-STD-CPL
+         PCL::COMPUTE-CONSTANTS PCL::ADD-FORMS PCL::AUGMENT-TYPE
+         PCL::MEMF-CONSTANT-CONVERTER PCL::SWAP-WRAPPERS-AND-SLOTS
+         PCL::SET-WRAPPER PCL::GET-KEY-ARG PCL::MAKE-PLIST
+         PCL::MAKE-PV-TABLE-INTERNAL ITERATE::EXTRACT-SPECIAL-BINDINGS
+         PCL::SAUT-NOT-EQL WALKER::VARIABLE-SYMBOL-MACRO-P
+         PCL::EMIT-1-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
+         PCL::SET-FUNCTION-PRETTY-ARGLIST
+         PCL::GF-MAKE-FUNCTION-FROM-EMF PCL::FIND-SLOT-DEFINITION
+         PCL::SET-STANDARD-SVUC-METHOD PCL::ADD-TO-CVECTOR
+         PCL::PV-WRAPPERS-FROM-ALL-WRAPPERS COMMON-LISP::REMOVE-METHOD
+         PCL::CHECKING-DFUN-INFO PCL::PARSE-QUALIFIER-PATTERN
+         PCL::%SET-CCLOSURE-ENV PCL::MAKE-CDXR
+         PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS
+         PCL::NET-CONSTANT-CONVERTER PCL::|SETF PCL FIND-CLASS|
+         PCL::METHOD-FUNCTION-RETURNING-T PCL::CHANGE-CLASS-INTERNAL
+         PCL::MAKE-DFUN-ARG-LIST PCL::DOCTOR-DFUN-FOR-THE-DEBUGGER
+         PCL::MAKE-STD-WRITER-METHOD-FUNCTION ITERATE::MV-SETQ
+         PCL::MAKE-EARLY-ACCESSOR PCL::GET-KEY-ARG1
+         PCL::ADD-DIRECT-SUBCLASSES PCL::DO-SATISFIES-DEFTYPE
+         PCL::N-N-DFUN-INFO PCL::CLASSES-HAVE-COMMON-SUBCLASS-P
+         PCL::SAUT-NOT-CLASS PCL::CANONICALIZE-DEFCLASS-OPTION
+         PCL::MAKE-DISCRIMINATING-FUNCTION-ARGLIST
+         WALKER::VARIABLE-LEXICAL-P WALKER::ENVIRONMENT-FUNCTION
+         PCL::PV-TABLE-LOOKUP PCL::DESTRUCTURE-INTERNAL
+         PCL::MAKE-INTERNAL-READER-METHOD-FUNCTION
+         PCL::REMOVE-SLOT-ACCESSORS
+         PCL::|SETF PCL FIND-CLASS-PREDICATE|
+         PCL::|SETF PCL GDEFINITION| PCL::MAKE-DFUN-LAMBDA-LIST
+         PCL::CANONICALIZE-SLOT-SPECIFICATION WALKER::WALK-REPEAT-EVAL
+         PCL::STANDARD-INSTANCE-ACCESS
+         PCL::PRINTING-RANDOM-THING-INTERNAL PCL::REMTAIL
+         PCL::ACCESSOR-MISS-FUNCTION PCL::COMPUTE-LAYOUT
+         PCL::CLASS-MIGHT-PRECEDE-P
+         PCL::EMIT-N-WRAPPER-COMPUTE-PRIMARY-CACHE-LOCATION
+         SYSTEM::%SET-COMPILED-FUNCTION-NAME PCL::PLIST-VALUE
+         PCL::MAKE-CAXR PCL::MAKE-DLAP-LAMBDA-LIST
+         PCL::MAKE-STD-READER-METHOD-FUNCTION WALKER::ENVIRONMENT-MACRO
+         PCL::UPDATE-SLOTS PCL::VARIABLE-CLASS
+         PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION PCL::LIST-EQ
+         PCL::ADD-SLOT-ACCESSORS PCL::SAUT-NOT-CLASS-EQ PCL::COMPUTE-PV
+         PCL::PV-WRAPPERS-FROM-ALL-ARGS PCL::UPDATE-INITS
+         PCL::MEC-ALL-CLASS-LISTS PCL::RAISE-METATYPE
+         WALKER::NOTE-DECLARATION PCL::EMIT-1-NIL-DLAP
+         PCL::BOOTSTRAP-SLOT-INDEX PCL::SUPERCLASSES-COMPATIBLE-P
+         PCL::MEC-ALL-CLASSES-INTERNAL COMMON-LISP::SLOT-EXISTS-P
+         PCL::DESCRIBE-PACKAGE PCL::NO-SLOT PCL::PROCLAIM-DEFGENERIC
+         COMMON-LISP::ADD-METHOD PCL::MAKE-UNORDERED-METHODS-EMF
+         PCL::MEC-ALL-CLASSES PCL::SYMBOL-OR-CONS-LESSP
+         PCL::UPDATE-INITIALIZE-INFO-INTERNAL PCL::CLASS-CAN-PRECEDE-P
+         PCL::SYMBOL-LESSP PCL::COMPUTE-APPLICABLE-METHODS-FUNCTION
+         PCL::MAKE-CLASS-PREDICATE WALKER::VARIABLE-SPECIAL-P
+         PCL::REMOVE-DIRECT-SUBCLASSES)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::FIXNUM)
-             COMMON-LISP::T)
-         PCL::COMPUTE-STD-CPL-PHASE-3)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::*)
+         PCL::MAKE-METHOD-FUNCTION-INTERNAL
+         PCL::MAKE-FINAL-DFUN-INTERNAL WALKER::MACROEXPAND-ALL
+         COMMON-LISP::ENSURE-GENERIC-FUNCTION
+         PCL::MAKE-METHOD-LAMBDA-INTERNAL PCL::MAKE-CONSTANT-VALUE-DFUN
+         PCL::GET-FUNCTION PCL::EXTRACT-DECLARATIONS
+         PCL::COERCE-TO-CLASS PCL::PARSE-METHOD-OR-SPEC
+         PCL::DISPATCH-DFUN-COST PCL::PARSE-SPECIALIZED-LAMBDA-LIST
+         PCL::MAP-ALL-CLASSES PCL::COMPILE-LAMBDA PCL::ENSURE-CLASS
+         PCL::GET-METHOD-FUNCTION WALKER::WALK-FORM
+         PCL::ALLOCATE-STRUCTURE-INSTANCE PCL::GET-FUNCTION1
+         PCL::MAKE-CACHING-DFUN PCL::MAKE-INSTANCE-1
+         PCL::GET-DFUN-CONSTRUCTOR)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::FIXNUM)
-             COMMON-LISP::T)
-         PCL::FILL-CACHE-FROM-CACHE-P PCL::GET-CACHE)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T)
+             (COMMON-LISP::VALUES COMMON-LISP::T COMMON-LISP::T))
+         PCL::MAKE-CLASS-PREDICATE-NAME PCL::MAKE-KEYWORD)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::LIST)
-         PCL::PV-TABLE-CALL-LIST PCL::CACHE-OVERFLOW
-         PCL::PV-TABLE-SLOT-NAME-LISTS)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+             (COMMON-LISP::VECTOR COMMON-LISP::CHARACTER
+                 COMMON-LISP::*))
+         PCL::CAPITALIZE-WORDS)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::T)
+         PCL::ALLOCATE-FUNCALLABLE-INSTANCE-1 PCL::SHOW-EMF-CALL-TRACE
+         PCL::CACHES-TO-ALLOCATE PCL::MAKE-CACHE
+         PCL::SHOW-FREE-CACHE-VECTORS PCL::MAKE-ARG-INFO
+         PCL::NO-METHODS-DFUN-INFO PCL::STRUCTURE-FUNCTIONS-EXIST-P
+         PCL::INITIALIZE-CHECKING-OR-CACHING-FUNCTION-LIST
+         PCL::BOOTSTRAP-BUILT-IN-CLASSES
+         PCL::%%ALLOCATE-INSTANCE--CLASS PCL::DISPATCH-DFUN-INFO
+         PCL::INITIAL-DISPATCH-DFUN-INFO PCL::BOOTSTRAP-META-BRAID
+         PCL::UPDATE-DISPATCH-DFUNS PCL::LIST-ALL-DFUNS
+         PCL::DEFAULT-METHOD-ONLY-DFUN-INFO PCL::RENEW-SYS-FILES
+         PCL::IN-THE-COMPILER-P PCL::GET-EFFECTIVE-METHOD-GENSYM
+         PCL::MAKE-CPD PCL::INITIAL-DFUN-INFO
+         PCL::SHOW-DFUN-CONSTRUCTORS
+         PCL::ALLOCATE-FUNCALLABLE-INSTANCE-2)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::FIXNUM)
+         PCL::ZERO)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::FIXNUM COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         PCL::COMPUTE-CACHE-PARAMETERS)) 
+             (COMMON-LISP::T COMMON-LISP::STREAM COMMON-LISP::T)
+             COMMON-LISP::T)
+         PCL::PRINT-DFUN-INFO)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
@@ -677,107 +406,86 @@
          PCL::FIND-FREE-CACHE-LINE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::BOOLEAN)
-         PCL::CACHE-VALUEP)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::FIXNUM COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         PCL::COMPUTE-CACHE-PARAMETERS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::*)
-         PCL::DEFAULT-CODE-CONVERTER PCL::EMIT-IN-CHECKING-CACHE-P
-         PCL::METHOD-PROTOTYPE-FOR-GF PCL::EMIT-TWO-CLASS-WRITER
-         PCL::PARSE-METHOD-GROUP-SPECIFIER PCL::EMIT-ONE-CLASS-WRITER
-         PCL::EMIT-ONE-INDEX-WRITERS PCL::FIND-STRUCTURE-CLASS
-         PCL::PROTOTYPES-FOR-MAKE-METHOD-LAMBDA PCL::MAKE-DISPATCH-DFUN
-         PCL::COMPUTE-APPLICABLE-METHODS-EMF PCL::EARLY-METHOD-FUNCTION
-         PCL::NET-CODE-CONVERTER PCL::GET-DISPATCH-FUNCTION
-         PCL::STRUCTURE-WRAPPER PCL::FIND-WRAPPER PCL::CLASS-EQ-TYPE
-         PCL::TYPE-FROM-SPECIALIZER PCL::SPECIALIZER-FROM-TYPE
-         PCL::PCL-DESCRIBE PCL::PARSE-DEFMETHOD
-         PCL::ANALYZE-LAMBDA-LIST PCL::EMIT-ONE-CLASS-READER
-         PCL::EARLY-COLLECT-INHERITANCE PCL::GET-GENERIC-FUNCTION-INFO
-         PCL::COMPILE-IIS-FUNCTIONS PCL::EMIT-CONSTANT-VALUE
-         PCL::EMIT-ONE-INDEX-READERS PCL::GENERIC-FUNCTION-NAME-P
-         PCL::CONVERT-TO-SYSTEM-TYPE PCL::MAKE-FINAL-DISPATCH-DFUN
-         PCL::EMIT-TWO-CLASS-READER PCL::*NORMALIZE-TYPE)) 
+         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*)
+         PCL::COUNT-ALL-DFUNS PCL::EMIT-N-N-WRITERS
+         PCL::EMIT-N-N-READERS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::T)
-         PCL::|__si::MAKE-CLASS-PRECEDENCE-DESCRIPTION|
-         PCL::MAKE-FAST-INSTANCE-BOUNDP PCL::MAKE-INITIALIZE-INFO
-         PCL::|STRUCTURE-OBJECT class constructor|
-         PCL::|__si::MAKE-CACHE| PCL::|__si::MAKE-DEFAULT-METHOD-ONLY|
-         PCL::TRUE PCL::|__si::MAKE-PV-TABLE|
-         PCL::|__si::MAKE-ONE-INDEX| WALKER::UNBOUND-LEXICAL-FUNCTION
-         PCL::|__si::MAKE-CHECKING| PCL::MAKE-PV-TABLE
-         PCL::|__si::MAKE-NO-METHODS| PCL::MAKE-METHOD-CALL
-         PCL::CALLED-FIN-WITHOUT-FUNCTION PCL::USE-PACKAGE-PCL
-         PCL::INTERN-PV-TABLE PCL::|__si::MAKE-ACCESSOR-DFUN-INFO|
-         PCL::|__si::MAKE-DISPATCH|
-         PCL::|__si::MAKE-ONE-INDEX-DFUN-INFO|
-         PCL::|__si::MAKE-ARG-INFO| PCL::FIX-EARLY-GENERIC-FUNCTIONS
-         PCL::ZERO PCL::MAKE-PROGN PCL::|__si::MAKE-INITIAL|
-         PCL::|__si::MAKE-ONE-CLASS| PCL::|__si::MAKE-DFUN-INFO|
-         PCL::|__si::MAKE-CONSTANT-VALUE|
-         PCL::|__si::MAKE-STD-INSTANCE| PCL::PV-WRAPPERS-FROM-PV-ARGS
-         PCL::|__si::MAKE-TWO-CLASS| PCL::|__si::MAKE-N-N|
-         PCL::|__si::MAKE-CACHING| PCL::FALSE PCL::STRING-APPEND
-         PCL::|__si::MAKE-INITIAL-DISPATCH| PCL::MAKE-FAST-METHOD-CALL)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::T)
+         PCL::MAKE-FINAL-DFUN PCL::SET-ARG-INFO PCL::TRACE-METHOD
+         PCL::MAKE-SPECIALIZABLE WALKER::WALKER-ENVIRONMENT-BIND-1
+         ITERATE::FUNCTION-LAMBDA-P COMMON-LISP::FIND-CLASS
+         PCL::MAKE-WRAPPER PCL::UPDATE-DFUN
+         PCL::MAKE-TYPE-PREDICATE-NAME PCL::PV-TABLE-LOOKUP-PV-ARGS
+         PCL::USE-CONSTANT-VALUE-DFUN-P WALKER::RELIST
+         PCL::MAKE-EARLY-GF PCL::INITIALIZE-METHOD-FUNCTION
+         PCL::FIND-CLASS-CELL PCL::USE-DISPATCH-DFUN-P
+         PCL::FIND-CLASS-PREDICATE PCL::ALLOCATE-STANDARD-INSTANCE
+         PCL::INITIALIZE-INTERNAL-SLOT-GFS ITERATE::MAYBE-WARN
+         PCL::ALLOCATE-FUNCALLABLE-INSTANCE
+         PCL::EARLY-METHOD-SPECIALIZERS WALKER::RELIST* PCL::SET-DFUN)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::*)
+         PCL::SLOT-UNBOUND-INTERNAL ITERATE::PARSE-DECLARATIONS
+         PCL::EMIT-CACHING PCL::COMPUTE-STD-CPL-PHASE-1
+         PCL::INITIAL-DFUN PCL::INSURE-DFUN PCL::EMIT-CHECKING
+         PCL::COMPUTE-TEST PCL::COMPUTE-CODE PCL::MAKE-DIRECT-SLOTD
+         PCL::SAUT-CLASS COMMON-LISP::SLOT-MAKUNBOUND
+         PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR PCL::INVOKE-EMF
+         PCL::*SUBTYPEP PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P
+         PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES
+         PCL::REAL-REMOVE-METHOD PCL::SAUT-PROTOTYPE
+         PCL::MUTATE-SLOTS-AND-CALLS PCL::FIND-SUPERCLASS-CHAIN
+         COMMON-LISP::SLOT-BOUNDP PCL::FORM-LIST-TO-LISP
+         PCL::CPL-INCONSISTENT-ERROR PCL::EMIT-DEFAULT-ONLY-FUNCTION
+         PCL::ENSURE-CLASS-VALUES PCL::CHECK-INITARGS-VALUES
+         PCL::SAUT-EQL PCL::SPLIT-DECLARATIONS
+         PCL::UPDATE-SLOT-VALUE-GF-INFO PCL::SAUT-AND
+         PCL::SLOT-NAME-LISTS-FROM-SLOTS
+         PCL::MAKE-INSTANCE-FUNCTION-TRAP PCL::EMIT-DEFAULT-ONLY
+         PCL::SAUT-NOT PCL::SAUT-CLASS-EQ COMMON-LISP::SLOT-VALUE
+         PCL::DESTRUCTURE PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P
+         PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL
+         PCL::CLASS-APPLICABLE-USING-CLASS-P PCL::SDFUN-FOR-CACHING
+         PCL::SET-FUNCTION-NAME)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::FIXNUM)
-         PCL::ARG-INFO-NUMBER-REQUIRED PCL::PV-TABLE-PV-SIZE
-         PCL::CACHE-COUNT PCL::PV-CACHE-LIMIT-FN PCL::CHECKING-LIMIT-FN
-         PCL::CACHING-LIMIT-FN PCL::N-N-ACCESSORS-LIMIT-FN
-         PCL::DEFAULT-LIMIT-FN PCL::EARLY-CLASS-SIZE PCL::CPD-COUNT
-         PCL::ONE-INDEX-LIMIT-FN PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
+         PCL::ARG-INFO-NUMBER-REQUIRED PCL::CACHING-LIMIT-FN
+         PCL::PV-CACHE-LIMIT-FN PCL::ONE-INDEX-LIMIT-FN
+         PCL::PV-TABLE-PV-SIZE PCL::CACHE-COUNT PCL::DEFAULT-LIMIT-FN
+         PCL::CPD-COUNT PCL::CHECKING-LIMIT-FN
+         PCL::N-N-ACCESSORS-LIMIT-FN PCL::EARLY-CLASS-SIZE
+         PCL::FAST-INSTANCE-BOUNDP-INDEX)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM) COMMON-LISP::T)
          PCL::POWER-OF-TWO-CEILING)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::*)
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*)
              COMMON-LISP::T)
-         PCL::MAKE-TYPE-PREDICATE-NAME PCL::MAKE-FINAL-DFUN
-         PCL::CAPITALIZE-WORDS PCL::SET-DFUN ITERATE::MAYBE-WARN
-         PCL::MAKE-EARLY-GF PCL::USE-DISPATCH-DFUN-P WALKER::RELIST
-         PCL::MAKE-SPECIALIZABLE PCL::PV-TABLE-LOOKUP-PV-ARGS
-         PCL::ALLOCATE-STANDARD-INSTANCE
-         PCL::ALLOCATE-FUNCALLABLE-INSTANCE
-         PCL::USE-CONSTANT-VALUE-DFUN-P ITERATE::FUNCTION-LAMBDA-P
-         PCL::UPDATE-DFUN PCL::SET-ARG-INFO
-         PCL::EARLY-METHOD-SPECIALIZERS PCL::MAKE-WRAPPER
-         PCL::FIND-CLASS-CELL WALKER::WALKER-ENVIRONMENT-BIND-1
-         PCL::TRACE-METHOD WALKER::RELIST* COMMON-LISP::FIND-CLASS
-         PCL::INITIALIZE-INTERNAL-SLOT-GFS PCL::FIND-CLASS-PREDICATE
-         PCL::INITIALIZE-METHOD-FUNCTION)) 
+         PCL::GET-CACHE-FROM-CACHE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         PCL::SAUT-NOT PCL::INVOKE-EMF PCL::SAUT-PROTOTYPE
-         PCL::COMPUTE-CODE ITERATE::PARSE-DECLARATIONS
-         PCL::SDFUN-FOR-CACHING
-         PCL::COMPUTE-APPLICABLE-METHODS-USING-TYPES
-         PCL::GET-NEW-FUNCTION-GENERATOR-INTERNAL
-         PCL::SLOT-NAME-LISTS-FROM-SLOTS PCL::DESTRUCTURE
-         PCL::SPLIT-DECLARATIONS PCL::MAKE-DIRECT-SLOTD
-         PCL::FORM-LIST-TO-LISP PCL::EMIT-CHECKING
-         PCL::CPL-FORWARD-REFERENCED-CLASS-ERROR PCL::COMPUTE-TEST
-         PCL::SET-FUNCTION-NAME COMMON-LISP::SLOT-BOUNDP PCL::SAUT-AND
-         PCL::EMIT-CACHING PCL::INITIAL-DFUN
-         COMMON-LISP::SLOT-MAKUNBOUND COMMON-LISP::SLOT-VALUE
-         PCL::UPDATE-SLOT-VALUE-GF-INFO
-         PCL::CLASS-APPLICABLE-USING-CLASS-P
-         PCL::CPL-INCONSISTENT-ERROR PCL::*SUBTYPEP
-         PCL::SLOT-UNBOUND-INTERNAL
-         PCL::GENERATE-FAST-CLASS-SLOT-ACCESS-P
-         PCL::CHECK-INITARGS-VALUES PCL::ENSURE-CLASS-VALUES
-         PCL::SAUT-EQL PCL::REAL-REMOVE-METHOD PCL::EMIT-DEFAULT-ONLY
-         PCL::INSURE-DFUN PCL::EMIT-DEFAULT-ONLY-FUNCTION
-         PCL::MUTATE-SLOTS-AND-CALLS PCL::FIND-SUPERCLASS-CHAIN
-         PCL::SAUT-CLASS PCL::MAKE-INSTANCE-FUNCTION-TRAP
-         PCL::SAUT-CLASS-EQ PCL::COMPUTE-STD-CPL-PHASE-1
-         PCL::SPECIALIZER-APPLICABLE-USING-TYPE-P)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM COMMON-LISP::T)
+             COMMON-LISP::FIXNUM)
+         PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) PCL::FIELD-TYPE)
+         PCL::CACHE-FIELD)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION (COMMON-LISP::T)
@@ -787,212 +495,533 @@
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
+             COMMON-LISP::T)
+         PCL::|(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+         WALKER::WALK-TEMPLATE PCL::|(FAST-METHOD PRINT-OBJECT (T T))|
+         WALKER::WALK-DO/DO* PCL::LOAD-PRECOMPILED-DFUN-CONSTRUCTOR
+         PCL::|(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))|
+         WALKER::WALK-LET/LET*
+         PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+         PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
+         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-TYPE
+         PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
+         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
+         PCL::|(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
+         PCL::INITIALIZE-INSTANCE-SIMPLE
+         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
+         PCL::EXPAND-SYMBOL-MACROLET-INTERNAL
+         PCL::|(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION1
+         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|
+         PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
+         PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
+         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+         PCL::|(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+         PCL::|(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+         PCL::|(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+         PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
+         PCL::|(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
+         PCL::|(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+         PCL::|(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
+         PCL::|(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
+         PCL::|(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
+         PCL::MAKE-DISPATCH-LAMBDA
+         PCL::|(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+         PCL::EXPAND-DEFCLASS
+         PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+         PCL::|(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
+         PCL::OPTIMIZE-WRITER
+         PCL::|(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD DOCUMENTATION (T))|
+         PCL::|(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
+         PCL::|(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+         PCL::OPTIMIZE-READER WALKER::WALK-PROG/PROG*
+         PCL::BOOTSTRAP-SET-SLOT
+         PCL::EMIT-CHECKING-OR-CACHING-FUNCTION-PRELIMINARY
+         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+         PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+         PCL::TWO-CLASS-DFUN-INFO
+         PCL::|(FAST-METHOD MAKE-INSTANCE (CLASS))|
+         PCL::|(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+         PCL::ADJUST-CACHE
+         PCL::|(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
+         PCL::|(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+         PCL::EXPAND-CACHE
+         PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
+         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
+         PCL::|(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
+         PCL::|(FAST-METHOD PRINT-OBJECT (CLASS T))|
+         PCL::|(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
+         PCL::|(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
+         PCL::|(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
+         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
+         PCL::|(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|
+         PCL::GET-WRAPPERS-FROM-CLASSES
+         PCL::|(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
+         PCL::MAYBE-EXPAND-ACCESSOR-FORM WALKER::WALK-BINDINGS-2
+         PCL::FILL-CACHE-P PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-INTERNAL
+         PCL::|(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
+         PCL::|(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|
+         PCL::|(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+         PCL::LOAD-PRECOMPILED-IIS-ENTRY PCL::MEMF-TEST-CONVERTER
+         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::T)
+         PCL::REAL-ADD-NAMED-METHOD PCL::EARLY-ADD-NAMED-METHOD
+         PCL::FILL-DFUN-CACHE)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::T)
+         PCL::OBSOLETE-INSTANCE-TRAP
+         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
+         WALKER::WALK-TAGBODY
+         PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+         PCL::ENTRY-IN-CACHE-P WALKER::WALK-COMPILER-LET
+         PCL::|(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
+         PCL::NOTE-PV-TABLE-REFERENCE PCL::COMPUTE-EFFECTIVE-METHOD
+         PCL::MAKE-DFUN-CALL PCL::|SETF PCL PLIST-VALUE|
+         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
+         PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
+         PCL::|(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
+         PCL::|(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
+         WALKER::WALK-UNEXPECTED-DECLARE
+         PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL
+         PCL::SKIP-FAST-SLOT-ACCESS-P PCL::SET-FUNCTION-NAME-1
+         WALKER::WALK-DO PCL::EMIT-1-T-DLAP PCL::PRINT-STD-INSTANCE
+         PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
+         WALKER::WALK-LAMBDA PCL::MAKE-METHOD-SPEC
+         PCL::|(FAST-METHOD CLASS-PREDICATE-NAME (T))|
+         PCL::|(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
+         PCL::OPTIMIZE-SET-SLOT-VALUE
+         PCL::MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+         PCL::EXPAND-DEFGENERIC WALKER::VARIABLE-DECLARATION
+         ITERATE::RENAME-AND-CAPTURE-VARIABLES
+         PCL::|(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|
+         PCL::MAP-ALL-ORDERS
+         PCL::|(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
+         PCL::DECLARE-STRUCTURE WALKER::WALK-PROG
+         PCL::|(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))|
+         PCL::OPTIMIZE-SLOT-VALUE WALKER::WALK-MULTIPLE-VALUE-BIND
+         PCL::|(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))|
+         PCL::STANDARD-COMPUTE-EFFECTIVE-METHOD WALKER::WALK-LOCALLY
+         PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
+         WALKER::WALK-DO*
+         PCL::|(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
+         PCL::MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+         PCL::EMIT-BOUNDP-CHECK WALKER::RECONS
+         PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
+         PCL::|(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
+         WALKER::WALK-LET* WALKER::WALK-TAGBODY-1 PCL::FLUSH-CACHE-TRAP
+         WALKER::WALK-FLET
+         PCL::|(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
+         PCL::|(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|
+         PCL::|(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
+         PCL::PRINT-CACHE
+         PCL::|(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|
+         PCL::INVALIDATE-WRAPPER PCL::GET-NEW-FUNCTION-GENERATOR
+         ITERATE::OPTIMIZE-ITERATE-FORM WALKER::RELIST-INTERNAL
+         PCL::CAN-OPTIMIZE-ACCESS PCL::MAKE-TOP-LEVEL-FORM
+         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
+         WALKER::WALK-MULTIPLE-VALUE-SETQ WALKER::WALK-LABELS
+         PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
+         PCL::|(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
+         PCL::|(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
+         WALKER::WALK-SETQ  WALKER::WALK-LET
+         PCL::|SETF PCL METHOD-FUNCTION-GET| WALKER::WALK-IF
+         PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
+         ITERATE::SIMPLE-EXPAND-GATHERING-FORM
+         PCL::|(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|
+         WALKER::WALK-NAMED-LAMBDA PCL::FIRST-FORM-TO-LISP
+         PCL::ONE-CLASS-DFUN-INFO
+         WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
+         PCL::EMIT-GREATER-THAN-1-DLAP PCL::CONVERT-TABLE
+         PCL::|(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
+         PCL::INITIALIZE-INTERNAL-SLOT-GFS*
+         ITERATE::OPTIMIZE-GATHERING-FORM
+         PCL::|(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
+         PCL::OPTIMIZE-SLOT-BOUNDP
+         PCL::|(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
+         PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
+         PCL::WRAP-METHOD-GROUP-SPECIFIER-BINDINGS
+         WALKER::WALK-SYMBOL-MACROLET ITERATE::VARIABLE-SAME-P
+         PCL::EMIT-SLOT-READ-FORM
+         PCL::SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P
+         PCL::|(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
+         PCL::GET-FUNCTION-GENERATOR
+         PCL::MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
+         PCL::FIX-SLOT-ACCESSORS
+         PCL::|(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
+         PCL::|(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
+         PCL::OPTIMIZE-GF-CALL-INTERNAL
+         PCL::|(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
+         PCL::|(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
+         PCL::|(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
+         PCL::|(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
+         PCL::|(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+         PCL::|(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
+         WALKER::WALK-PROG* PCL::ONE-INDEX-DFUN-INFO
+         PCL::COMPUTE-PRECEDENCE PCL::TRACE-EMF-CALL-INTERNAL
+         WALKER::WALK-MACROLET)) 
+(COMMON-LISP::PROCLAIM
+    '(COMMON-LISP::FTYPE
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
                  COMMON-LISP::*)
-             COMMON-LISP::*)
-         WALKER::WALK-DECLARATIONS PCL::GET-SECONDARY-DISPATCH-FUNCTION
-         PCL::MAKE-ONE-INDEX-ACCESSOR-DFUN)) 
+             COMMON-LISP::T)
+         PCL::MAKE-DEFMETHOD-FORM-INTERNAL PCL::LOAD-DEFMETHOD
+         PCL::EARLY-MAKE-A-METHOD PCL::MAKE-DEFMETHOD-FORM)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
-             COMMON-LISP::*)
-         PCL::MAKE-SHARED-INITIALIZE-FORM-LIST PCL::ACCESSOR-MISS
-         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
-         PCL::|(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
-         PCL::|(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-         PCL::|(FAST-METHOD NO-APPLICABLE-METHOD (T))|
-         PCL::SET-CLASS-SLOT-VALUE-1
-         PCL::|(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
-         PCL::|(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
-         PCL::GET-ACCESSOR-FROM-SVUC-METHOD-FUNCTION
-         PCL::SETF-SLOT-VALUE-USING-CLASS-DFUN
-         PCL::|(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
-         PCL::EMIT-CHECKING-OR-CACHING-FUNCTION
-         PCL::MAKE-FINAL-ONE-INDEX-ACCESSOR-DFUN
-         PCL::LOAD-SHORT-DEFCOMBIN PCL::EMIT-CHECKING-OR-CACHING
-         PCL::|(FAST-METHOD MAKE-INSTANCE (SYMBOL))|
-         PCL::MAKE-FINAL-CHECKING-DFUN
-         PCL::|(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
-         PCL::|(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
-         PCL::ACCESSOR-VALUES
-         PCL::|(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
-         PCL::REAL-MAKE-METHOD-LAMBDA
-         PCL::|(FAST-METHOD CHANGE-CLASS (T SYMBOL))|
-         PCL::GET-ACCESSOR-METHOD-FUNCTION
-         PCL::|(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
-         PCL::|(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))|
-         PCL::ORDER-SPECIALIZERS
-         PCL::|(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
-         PCL::GENERATE-DISCRIMINATION-NET
-         PCL::|(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
-         PCL::|(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
-         PCL::MAKE-ONE-CLASS-ACCESSOR-DFUN
-         PCL::|(FAST-METHOD DESCRIBE-OBJECT (T T))|
-         PCL::BOOTSTRAP-ACCESSOR-DEFINITION
-         PCL::INITIALIZE-INSTANCE-SIMPLE-FUNCTION)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
+             COMMON-LISP::T)
+         PCL::GET-EFFECTIVE-METHOD-FUNCTION1
+         PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS
+         PCL::MAKE-EMF-FROM-METHOD
+         PCL::REAL-ENSURE-GF-USING-CLASS--NULL PCL::PROBE-CACHE
+         PCL::MAP-CACHE PCL::GET-DECLARATION
+         PCL::REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION
+         WALKER::CONVERT-MACRO-TO-LAMBDA
+         PCL::EXPAND-EFFECTIVE-METHOD-FUNCTION PCL::EMIT-MISS
+         PCL::GET-METHOD-FUNCTION-PV-CELL PCL::METHOD-FUNCTION-GET
+         PCL::FIND-CLASS-FROM-CELL PCL::RECORD-DEFINITION
+         PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION1
+         PCL::FIND-CLASS-PREDICATE-FROM-CELL
+         PCL::NAMED-OBJECT-PRINT-FUNCTION
+         PCL::PRECOMPUTE-EFFECTIVE-METHODS PCL::INITIALIZE-INFO
+         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         PCL::GET-OPTIMIZED-STD-ACCESSOR-METHOD-FUNCTION
-         PCL::MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
-         PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
-         PCL::|(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|
-         PCL::|(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
-         PCL::MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION
-         PCL::CONVERT-METHODS WALKER::WALK-LET-IF
-         PCL::EMIT-READER/WRITER-FUNCTION PCL::ACCESSOR-VALUES-INTERNAL
-         PCL::|(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|
-         PCL::LOAD-LONG-DEFCOMBIN PCL::CHECK-METHOD-ARG-INFO
-         PCL::ACCESSOR-VALUES1
-         PCL::|(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
-         PCL::GENERATING-LISP PCL::MAKE-FINAL-N-N-ACCESSOR-DFUN
-         WALKER::WALK-FORM-INTERNAL PCL::CONSTANT-VALUE-MISS
-         PCL::SLOT-VALUE-USING-CLASS-DFUN PCL::CACHING-MISS
-         PCL::|(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
-         PCL::SLOT-BOUNDP-USING-CLASS-DFUN PCL::CHECKING-MISS
-         PCL::|(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
-         PCL::EMIT-READER/WRITER ITERATE::EXPAND-INTO-LET
-         PCL::GET-CLASS-SLOT-VALUE-1
-         PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER-FUNCTION
-         PCL::MAKE-FINAL-CACHING-DFUN
-         PCL::|(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
-         PCL::|(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
-         PCL::GET-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
-         PCL::|(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
-         PCL::OPTIMIZE-SLOT-VALUE-BY-CLASS-P PCL::SET-SLOT-VALUE
-         PCL::EMIT-ONE-OR-N-INDEX-READER/WRITER
-         ITERATE::RENAME-VARIABLES
-         PCL::|(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|
-         PCL::|(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|
-         ITERATE::WALK-GATHERING-BODY PCL::CACHE-MISS-VALUES
-         PCL::MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
-         PCL::MAKE-FINAL-CONSTANT-VALUE-DFUN)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::T)
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
+         PCL::MAKE-METHOD-INITARGS-FORM-INTERNAL1
+         PCL::GET-MAKE-INSTANCE-FUNCTION-INTERNAL
+         PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS1 PCL::MAKE-EMF-CACHE
+         PCL::|(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
+         PCL::MAKE-FGEN
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
+         PCL::BOOTSTRAP-MAKE-SLOT-DEFINITIONS
+         PCL::|(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::|(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::OPTIMIZE-ACCESSOR-CALL
+         PCL::MAKE-INSTANCE-FUNCTION-COMPLEX PCL::UPDATE-SLOTS-IN-PV
+         PCL::COMPUTE-PV-SLOT
+         PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
+         PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|
+         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
+         PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T T))|
+         PCL::OPTIMIZE-INSTANCE-ACCESS
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
+         PCL::MAKE-INSTANCE-FUNCTION-SIMPLE
+         PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::OPTIMIZE-GENERIC-FUNCTION-CALL
+         PCL::LOAD-FUNCTION-GENERATOR WALKER::WALK-BINDINGS-1
+         PCL::|(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
+         PCL::REAL-MAKE-METHOD-INITARGS-FORM
+         PCL::|(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
+         PCL::|(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+         WALKER::WALK-TEMPLATE-HANDLE-REPEAT
+         PCL::MAKE-PARAMETER-REFERENCES
+         PCL::|(FAST-METHOD SLOT-UNBOUND (T T T))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
+         PCL::EXPAND-EMF-CALL-METHOD
+         PCL::|(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
+         PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
+         PCL::|(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
+         PCL::MAKE-FINAL-ORDINARY-DFUN-INTERNAL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         PCL::DO-SHORT-METHOD-COMBINATION PCL::MEMF-CODE-CONVERTER
-         PCL::GENERATE-DISCRIMINATION-NET-INTERNAL
-         PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::MAKE-LONG-METHOD-COMBINATION-FUNCTION
-         PCL::CACHE-MISS-VALUES-INTERNAL)) 
+                 COMMON-LISP::*)
+             COMMON-LISP::T)
+         PCL::GET-METHOD WALKER::WALK-ARGLIST PCL::REAL-GET-METHOD
+         PCL::EMIT-FETCH-WRAPPER PCL::CHECK-INITARGS-2-LIST
+         PCL::FILL-CACHE PCL::CHECK-INITARGS-2-PLIST PCL::MAKE-EMF-CALL
+         PCL::CHECK-INITARGS-1 PCL::CAN-OPTIMIZE-ACCESS1)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
                  COMMON-LISP::T COMMON-LISP::T)
-             COMMON-LISP::*)
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
-         PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|
-         PCL::ADD-METHOD-DECLARATIONS
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
-         PCL::|(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
-         PCL::COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO-INTERNAL
-         PCL::|(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
-         PCL::|(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
-         PCL::MAKE-TWO-CLASS-ACCESSOR-DFUN
-         PCL::|(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
-         PCL::|(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
-         PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::|(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
-         PCL::|(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
-         PCL::|(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
-         PCL::|(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-         PCL::WALK-METHOD-LAMBDA
-         PCL::|(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|)) 
+             COMMON-LISP::T)
+         PCL::GET-SECONDARY-DISPATCH-FUNCTION2)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
              (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::*)
-             COMMON-LISP::*)
-         PCL::REAL-MAKE-A-METHOD)) 
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T)
+             COMMON-LISP::T)
+         PCL::REAL-LOAD-DEFCLASS PCL::LOAD-DEFCLASS PCL::SET-ARG-INFO1
+         PCL::BOOTSTRAP-MAKE-SLOT-DEFINITION PCL::EMIT-SLOT-ACCESS
+         WALKER::WALK-TEMPLATE-HANDLE-REPEAT-1 PCL::OPTIMIZE-GF-CALL
+         PCL::|(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+         PCL::MAKE-EARLY-CLASS-DEFINITION)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::*)
-         PCL::MAKE-DEFAULT-INITARGS-FORM-LIST
-         PCL::GET-COMPLEX-INITIALIZATION-FUNCTIONS
-         PCL::SLOT-VALUE-OR-DEFAULT
-         PCL::GET-SIMPLE-INITIALIZATION-FUNCTION PCL::REAL-ADD-METHOD
-         PCL::LOAD-DEFGENERIC PCL::CPL-ERROR
-         PCL::MAKE-FINAL-ACCESSOR-DFUN PCL::MAKE-N-N-ACCESSOR-DFUN
-         PCL::TYPES-FROM-ARGUMENTS PCL::MAKE-ACCESSOR-TABLE
-         PCL::MAKE-CHECKING-DFUN WALKER::NESTED-WALK-FORM
-         PCL::GET-EFFECTIVE-METHOD-FUNCTION
-         PCL::COMPUTE-SECONDARY-DISPATCH-FUNCTION
-         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION)) 
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::FIXNUM)
+             COMMON-LISP::T)
+         PCL::GET-CACHE PCL::FILL-CACHE-FROM-CACHE-P)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T)
-             COMMON-LISP::*)
-         ITERATE::ITERATE-TRANSFORM-BODY
-         PCL::|(FAST-METHOD SLOT-MISSING (T T T T))|
-         PCL::|(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|)) 
+             (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*)
+             COMMON-LISP::FIXNUM)
+         PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
-                 COMMON-LISP::T COMMON-LISP::*)
-             COMMON-LISP::*)
-         PCL::MAKE-EFFECTIVE-METHOD-FUNCTION-SIMPLE1
-         ITERATE::RENAME-LET-BINDINGS)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::T)
+         PCL::EVAL-FORM PCL::EARLY-CLASS-NAME-OF PCL::DFUN-INFO-CACHE
+         PCL::MAKE-CONSTANT-FUNCTION PCL::EXPAND-SHORT-DEFCOMBIN
+         PCL::COPY-CACHE PCL::PROCLAIM-INCOMPATIBLE-SUPERCLASSES
+         PCL::MAKE-INITIAL-DFUN PCL::ECD-METACLASS
+         PCL::EXTRACT-SPECIALIZER-NAMES PCL::GBOUNDP
+         PCL::GET-SETF-FUNCTION-NAME PCL::USE-CACHING-DFUN-P
+         PCL::INITIALIZE-INFO-CACHED-CONSTANTS
+         PCL::STRUCTURE-TYPE-INTERNAL-SLOTDS COMMON-LISP::CLASS-OF
+         PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION
+         PCL::ARG-INFO-KEY/REST-P PCL::METHOD-CALL-CALL-METHOD-ARGS
+         PCL::FGEN-GENSYMS PCL::EARLY-CLASS-PRECEDENCE-LIST
+         PCL::EARLY-SLOT-DEFINITION-LOCATION
+         PCL::EXPAND-MAKE-INSTANCE-FORM PCL::INTERN-EQL-SPECIALIZER
+         PCL::METHOD-FUNCTION-METHOD PCL::FGEN-GENERATOR-LAMBDA
+         PCL::SLOT-READER-SYMBOL PCL::CACHING-P
+         PCL::EARLY-METHOD-QUALIFIERS
+         PCL::EARLY-COLLECT-DEFAULT-INITARGS PCL::KEYWORD-SPEC-NAME
+         PCL::ONE-INDEX-P PCL::COMPLICATED-INSTANCE-CREATION-METHOD
+         PCL::DFUN-ARG-SYMBOL PCL::N-N-CACHE
+         PCL::ONE-INDEX-DFUN-INFO-INDEX PCL::INITIAL-DISPATCH-CACHE
+         PCL::CPD-CLASS PCL::FAST-METHOD-CALL-ARG-INFO
+         PCL::MAKE-PV-TYPE-DECLARATION PCL::COMPUTE-STD-CPL-PHASE-2
+         PCL::GET-BUILT-IN-CLASS-SYMBOL
+         PCL::INITIALIZE-INFO-CACHED-RI-VALID-P
+         PCL::UPDATE-GFS-OF-CLASS PCL::STRUCTURE-SVUC-METHOD
+         PCL::SLOT-BOUNDP-SYMBOL PCL::FGEN-SYSTEM
+         PCL::FIND-CYCLE-REASONS ITERATE::SEQUENCE-ACCESSOR
+         PCL::GF-INFO-C-A-M-EMF-STD-P PCL::STRUCTURE-TYPE-P
+         PCL::TWO-CLASS-CACHE PCL::METHOD-LL->GENERIC-FUNCTION-LL
+         PCL::ONE-CLASS-ACCESSOR-TYPE PCL::WRAPPER-FOR-STRUCTURE
+         PCL::ACCESSOR-DFUN-INFO-CACHE PCL::%SYMBOL-FUNCTION
+         PCL::STRUCTURE-TYPE PCL::NET-TEST-CONVERTER
+         PCL::CONSTANT-SYMBOL-P PCL::GMAKUNBOUND PCL::INITIAL-P
+         PCL::GF-DFUN-CACHE PCL::STRUCTURE-SLOTD-TYPE
+         PCL::%STD-INSTANCE-WRAPPER PCL::INITIALIZE-INFO-P
+         PCL::CACHING-DFUN-INFO
+         PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+         PCL::FAST-METHOD-CALL-P PCL::GF-DFUN-INFO
+         PCL::INITIALIZE-INFO-BOUND-SLOTS PCL::ECD-CLASS-NAME
+         PCL::MAKE-INSTANCE-FUNCTION-SYMBOL
+         PCL::INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION
+         PCL::STD-INSTANCE-P PCL::EXTRACT-PARAMETERS
+         WALKER::GET-WALKER-TEMPLATE PCL::SYMBOL-PKG-NAME
+         PCL::CCLOSUREP PCL::LOOKUP-FGEN PCL::CPD-SUPERS
+         PCL::ARG-INFO-KEYWORDS PCL::DISPATCH-P
+         PCL::INITIALIZE-INFO-CACHED-NEW-KEYS
+         PCL::MAKE-CALLS-TYPE-DECLARATION PCL::INITIALIZE-INFO-WRAPPER
+         PCL::%FBOUNDP PCL::DEFAULT-STRUCTURE-INSTANCE-P
+         WALKER::ENV-WALK-FORM PCL::EARLY-CLASS-DEFINITION
+         PCL::SORT-CALLS PCL::EARLY-METHOD-STANDARD-ACCESSOR-SLOT-NAME
+         PCL::DISPATCH-CACHE PCL::INITIALIZE-INFO-KEY
+         PCL::MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
+         PCL::ARG-INFO-METATYPES PCL::GF-LAMBDA-LIST
+         WALKER::ENV-LEXICAL-VARIABLES PCL::ACCESSOR-DFUN-INFO-P
+         PCL::GF-PRECOMPUTE-DFUN-AND-EMF-P PCL::COMPUTE-LINE-SIZE
+         PCL::INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION
+         PCL::FORCE-CACHE-FLUSHES PCL::TWO-CLASS-P PCL::DFUN-INFO-P
+         PCL::MAP-SPECIALIZERS PCL::MAKE-PERMUTATION-VECTOR
+         WALKER::ENV-LOCK PCL::CPD-AFTER PCL::EARLY-CLASS-SLOTS
+         PCL::GET-PV-CELL-FOR-CLASS PCL::ARG-INFO-P
+         PCL::EXTRACT-REQUIRED-PARAMETERS
+         PCL::STRUCTURE-SLOTD-READER-FUNCTION PCL::COMPUTE-CLASS-SLOTS
+         PCL::INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS
+         PCL::TWO-CLASS-WRAPPER0
+         PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
+         PCL::COMPILE-LAMBDA-UNCOMPILED PCL::EARLY-CLASS-NAME
+         PCL::SFUN-P PCL::EXTRACT-LAMBDA-LIST PCL::UNDEFMETHOD-1
+         PCL::ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE PCL::WRAPPER-OF
+         PCL::ARG-INFO-LAMBDA-LIST PCL::LIST-DFUN
+         PCL::NEXT-WRAPPER-FIELD PCL::CHECK-WRAPPER-VALIDITY
+         PCL::STRUCTURE-SLOTD-NAME PCL::BUILT-IN-WRAPPER-OF
+         PCL::GET-MAKE-INSTANCE-FUNCTIONS
+         PCL::GENERIC-CLOBBERS-FUNCTION PCL::NO-METHODS-P
+         PCL::CONSTANT-VALUE-P WALKER::ENV-WALK-FUNCTION
+         PCL::INITIAL-CACHE PCL::SLOT-INITARGS-FROM-STRUCTURE-SLOTD
+         PCL::MAKE-CLASS-EQ-PREDICATE
+         PCL::GET-MAKE-INSTANCE-FUNCTION-SYMBOL
+         PCL::BOOTSTRAP-ACCESSOR-DEFINITIONS
+         PCL::FUNCTION-PRETTY-ARGLIST
+         PCL::MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
+         PCL::FTYPE-DECLARATION-FROM-LAMBDA-LIST PCL::TYPE-CLASS
+         PCL::CHECK-CACHE PCL::STANDARD-SVUC-METHOD
+         PCL::STRUCTURE-SLOTD-ACCESSOR-SYMBOL PCL::GF-INFO-FAST-MF-P
+         PCL::STRUCTURE-SLOTD-WRITER-FUNCTION
+         PCL::BOOTSTRAP-CLASS-PREDICATES PCL::DEFAULT-METHOD-ONLY-CACHE
+         PCL::GET-CACHE-VECTOR PCL::SLOT-WRITER-SYMBOL
+         PCL::FGEN-GENERATOR PCL::DNET-METHODS-P
+         PCL::DEFAULT-STRUCTURE-TYPE
+         PCL::INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
+         PCL::N-N-ACCESSOR-TYPE
+         PCL::STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST
+         WALKER::ENV-DECLARATIONS WALKER::VARIABLE-GLOBALLY-SPECIAL-P
+         PCL::ONE-INDEX-INDEX PCL::ONE-INDEX-DFUN-INFO-CACHE
+         PCL::EARLY-ACCESSOR-METHOD-SLOT-NAME PCL::EARLY-CLASS-SLOTDS
+         PCL::CANONICAL-SLOT-NAME PCL::EARLY-COLLECT-CPL
+         PCL::RESET-CLASS-INITIALIZE-INFO-1
+         PCL::BUILT-IN-OR-STRUCTURE-WRAPPER1 PCL::ONE-INDEX-CACHE
+         PCL::MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION
+         PCL::MAKE-TYPE-PREDICATE PCL::FREE-CACHE
+         ITERATE::VARIABLES-FROM-LET
+         PCL::EARLY-METHOD-STANDARD-ACCESSOR-P
+         PCL::DEFAULT-CONSTANT-CONVERTER PCL::CLASS-PREDICATE
+         PCL::CHECKING-CACHE PCL::ARG-INFO-PRECEDENCE
+         PCL::METHOD-FUNCTION-NEEDS-NEXT-METHODS-P
+         PCL::DEFAULT-METHOD-ONLY-P
+         PCL::COMPUTE-APPLICABLE-METHODS-EMF-STD-P
+         PCL::STRUCTURE-SLOT-BOUNDP PCL::ONE-INDEX-ACCESSOR-TYPE
+         PCL::TWO-CLASS-ACCESSOR-TYPE
+         PCL::USE-DEFAULT-METHOD-ONLY-DFUN-P PCL::METHOD-CALL-P
+         PCL::UPDATE-CLASS-CAN-PRECEDE-P PCL::CONSTANT-VALUE-DFUN-INFO
+         PCL::COMPILE-LAMBDA-DEFERRED PCL::SETFBOUNDP
+         PCL::CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P
+         PCL::PV-TABLEP PCL::STRUCTURE-OBJECT-P PCL::TWO-CLASS-INDEX
+         PCL::METHOD-FUNCTION-PV-TABLE PCL::ECD-OTHER-INITARGS
+         WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
+         PCL::EARLY-GF-P PCL::STRUCTURE-SLOTD-INIT-FORM
+         PCL::FUNCALLABLE-INSTANCE-P PCL::CHECKING-FUNCTION
+         PCL::FUNCTION-RETURNING-NIL PCL::FUNCTION-RETURNING-T
+         PCL::UPDATE-C-A-M-GF-INFO PCL::COUNT-DFUN
+         PCL::UNPARSE-SPECIALIZERS PCL::CACHE-OWNER
+         PCL::EARLY-METHOD-CLASS
+         PCL::INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION
+         PCL::EARLY-SLOT-DEFINITION-NAME
+         PCL::GET-MAKE-INSTANCE-FUNCTION
+         PCL::STRUCTURE-TYPE-INCLUDED-TYPE-NAME
+         PCL::ECD-SUPERCLASS-NAMES PCL::GFS-OF-TYPE PCL::SORT-SLOTS
+         PCL::DO-STANDARD-DEFSETFS-FOR-DEFCLASS
+         PCL::COMPUTE-MCASE-PARAMETERS PCL::METHOD-FUNCTION-PLIST
+         PCL::ARG-INFO-NKEYS PCL::FINAL-ACCESSOR-DFUN-TYPE
+         PCL::EARLY-COLLECT-SLOTS PCL::EARLY-METHOD-LAMBDA-LIST
+         PCL::FAST-INSTANCE-BOUNDP-P PCL::GDEFINITION
+         PCL::%CCLOSURE-ENV SYSTEM::%COMPILED-FUNCTION-NAME
+         PCL::RESET-INITIALIZE-INFO PCL::ARG-INFO-NUMBER-OPTIONAL
+         PCL::RESET-CLASS-INITIALIZE-INFO
+         PCL::INITIALIZE-INFO-CACHED-VALID-P PCL::INTERNED-SYMBOL-P
+         PCL::EARLY-GF-NAME PCL::FGEN-TEST PCL::MAKE-INITFUNCTION
+         PCL::MAP-ALL-GENERIC-FUNCTIONS PCL::SHOW-DFUN-COSTS
+         PCL::CLASS-FROM-TYPE PCL::EXPAND-LONG-DEFCOMBIN
+         PCL::MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION
+         PCL::FREE-CACHE-VECTOR PCL::%STD-INSTANCE-SLOTS
+         PCL::ALLOCATE-CACHE-VECTOR PCL::ONE-CLASS-P
+         PCL::CLASS-PRECEDENCE-DESCRIPTION-P PCL::SLOT-VECTOR-SYMBOL
+         PCL::INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION
+         PCL::ONE-CLASS-WRAPPER0 PCL::N-N-P
+         PCL::UPDATE-ALL-C-A-M-GF-INFO PCL::CHECKING-P
+         PCL::TWO-CLASS-WRAPPER1 PCL::PARSE-SPECIALIZERS
+         PCL::FORMAT-CYCLE-REASONS PCL::FLUSH-CACHE-VECTOR-INTERNAL
+         PCL::UNENCAPSULATED-FDEFINITION PCL::ONE-CLASS-INDEX
+         PCL::DEFAULT-CONSTANTP PCL::UPDATE-GF-INFO
+         PCL::ACCESSOR-DFUN-INFO-ACCESSOR-TYPE
+         PCL::INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST
+         PCL::MAKE-EQL-PREDICATE PCL::ARG-INFO-VALID-P
+         PCL::CACHING-CACHE PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
+         PCL::FAST-METHOD-CALL-NEXT-METHOD-CALL
+         PCL::DEFAULT-SECONDARY-DISPATCH-FUNCTION
+         PCL::MAKE-FUNCTION-INLINE PCL::STORE-FGEN
+         PCL::LIST-LARGE-CACHE PCL::METHODS-CONTAIN-EQL-SPECIALIZER-P
+         PCL::ARG-INFO-APPLYP SYSTEM::%STRUCTURE-NAME
+         PCL::GF-INFO-SIMPLE-ACCESSOR-TYPE PCL::ECD-SOURCE
+         PCL::EARLY-CLASS-DIRECT-SUBCLASSES
+         PCL::UPDATE-PV-TABLE-CACHE-INFO PCL::DEFAULT-TEST-CONVERTER
+         PCL::MAKE-CALL-METHODS PCL::GET-BUILT-IN-WRAPPER-SYMBOL
+         PCL::GF-INFO-STATIC-C-A-M-EMF PCL::DEFAULT-STRUCTUREP
+         PCL::CONSTANT-VALUE-CACHE PCL::INITIAL-DISPATCH-P
+         PCL::ECD-CANONICAL-SLOTS PCL::WRAPPER-FIELD
+         PCL::UPDATE-GF-SIMPLE-ACCESSOR-TYPE PCL::ONE-CLASS-CACHE
+         PCL::CACHING-DFUN-COST PCL::LEGAL-CLASS-NAME-P
+         PCL::INTERN-FUNCTION-NAME PCL::FAST-METHOD-CALL-PV-CELL
+         PCL::CACHE-P PCL::ONE-INDEX-DFUN-INFO-P
+         PCL::MAKE-PV-TABLE-TYPE-DECLARATION PCL::NO-METHODS-CACHE)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION
-             (COMMON-LISP::FIXNUM COMMON-LISP::FIXNUM COMMON-LISP::T)
-             COMMON-LISP::FIXNUM)
-         PCL::COMPUTE-PRIMARY-CACHE-LOCATION)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::*) COMMON-LISP::*)
+         PCL::UPDATE-MAKE-INSTANCE-FUNCTION-TABLE PCL::UNTRACE-METHOD
+         COMMON-LISP::METHOD-COMBINATION-ERROR
+         COMMON-LISP::INVALID-METHOD-ERROR PCL::LIST-LARGE-CACHES)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::FIXNUM COMMON-LISP::*)
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::*)
              COMMON-LISP::T)
-         PCL::COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION
-         PCL::GET-CACHE-FROM-CACHE)) 
+         PCL::EMIT-DLAP PCL::GET-SECONDARY-DISPATCH-FUNCTION1)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION (COMMON-LISP::FIXNUM COMMON-LISP::T)
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T
+                 (COMMON-LISP::INTEGER -9223372036854775808
+                     9223372036854775807))
              COMMON-LISP::T)
-         PCL::%CCLOSURE-ENV-NTHCDR)) 
+         PCL::COMPUTE-STD-CPL-PHASE-3)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
          (COMMON-LISP::FUNCTION
-             (COMMON-LISP::T COMMON-LISP::STREAM COMMON-LISP::T)
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T)
              COMMON-LISP::T)
-         PCL::PRINT-DFUN-INFO)) 
+         PCL::EXPAND-DEFMETHOD PCL::LOAD-DEFMETHOD-INTERNAL)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::*)
-         PCL::COUNT-ALL-DFUNS PCL::EMIT-N-N-WRITERS
-         PCL::EMIT-N-N-READERS)) 
+         (COMMON-LISP::FUNCTION
+             (COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::T COMMON-LISP::T COMMON-LISP::T
+                 COMMON-LISP::*)
+             COMMON-LISP::T)
+         PCL::BOOTSTRAP-INITIALIZE-CLASS)) 
 (COMMON-LISP::PROCLAIM
     '(COMMON-LISP::FTYPE
-         (COMMON-LISP::FUNCTION COMMON-LISP::NIL COMMON-LISP::FIXNUM)
-         PCL::GET-WRAPPER-CACHE-NUMBER)) 
+         (COMMON-LISP::FUNCTION (COMMON-LISP::T) COMMON-LISP::LIST)
+         PCL::PV-TABLE-CALL-LIST PCL::CACHE-OVERFLOW
+         PCL::PV-TABLE-SLOT-NAME-LISTS)) 
 (IN-PACKAGE "PCL")
 
-(DOLIST (V '(|(FAST-WRITER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
-                |(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-METHODS)|
+(DOLIST (V '(|(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-METHODS)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT SLOTS)|
                 |(FAST-WRITER-METHOD SLOT-CLASS SLOTS)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
                 |(FAST-WRITER-METHOD SLOT-CLASS DIRECT-SLOTS)|
+                |(FAST-WRITER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT METHODS)|
                 |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT OPTIONS)|
@@ -1034,17 +1063,16 @@
                 COMPATIBLE-META-CLASS-CHANGE-P
                 |(FAST-READER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
                 |(FAST-READER-METHOD CLASS CLASS-EQ-SPECIALIZER)|
-                |(BOUNDP READER-FUNCTION)| TRACE-METHOD-INTERNAL
-                |(BOUNDP PREDICATE-NAME)| |(BOUNDP READERS)|
-                UPDATE-GF-DFUN |(BOUNDP CLASS-PRECEDENCE-LIST)|
+                |(BOUNDP READER-FUNCTION)| |(BOUNDP PREDICATE-NAME)|
+                |(BOUNDP READERS)| UPDATE-GF-DFUN
+                |(BOUNDP CLASS-PRECEDENCE-LIST)|
                 |(BOUNDP ACCESSOR-FLAGS)| |(BOUNDP LOCATION)|
                 |(BOUNDP DOCUMENTATION)| SPECIALIZER-OBJECT
                 |(BOUNDP INCOMPATIBLE-SUPERCLASS-LIST)|
                 ACCESSOR-METHOD-SLOT-NAME |(BOUNDP SPECIALIZERS)|
                 |(BOUNDP IDENTITY-WITH-ONE-ARGUMENT)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
-                REDEFINE-FUNCTION SPECIALIZER-CLASS
-                |(BOUNDP PRETTY-ARGLIST)|
+                SPECIALIZER-CLASS |(BOUNDP PRETTY-ARGLIST)|
                 |PCL::PCL-CLASS class predicate|
                 |PCL::STD-CLASS class predicate|
                 |(BOUNDP DEFSTRUCT-FORM)|
@@ -1082,104 +1110,104 @@
                 |(BOUNDP OPTIONS)| |(WRITER METHOD)|
                 |PCL::DEPENDENT-UPDATE-MIXIN class predicate|
                 GENERIC-FUNCTION-PRETTY-ARGLIST |(WRITER SOURCE)|
+                |(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
                 |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (SPECIALIZER-WITH-OBJECT))|
                 |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (SPECIALIZER-WITH-OBJECT))|
-                |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
                 |(FAST-METHOD UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|
+                |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
                 |(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
-                |(FAST-METHOD SLOTS-TO-INSPECT (SLOT-CLASS SLOT-OBJECT))|
-                |(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
-                |(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
                 |(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
-                |(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
                 |(FAST-METHOD SAME-SPECIALIZER-P (EQL-SPECIALIZER EQL-SPECIALIZER))|
+                |(FAST-METHOD SAME-SPECIALIZER-P (CLASS-EQ-SPECIALIZER CLASS-EQ-SPECIALIZER))|
                 |(FAST-METHOD SAME-SPECIALIZER-P (SPECIALIZER SPECIALIZER))|
+                |(FAST-METHOD SPECIALIZER-METHOD-TABLE (CLASS-EQ-SPECIALIZER))|
+                |(FAST-METHOD SPECIALIZER-METHOD-TABLE (EQL-SPECIALIZER))|
                 MAKE-BOUNDP-METHOD-FUNCTION
                 |(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))|
                 |(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))|
                 |PCL::METAOBJECT class predicate|
-                |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-                |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-                |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-                |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
+                |(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
+                |(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
+                |(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
+                |(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|
                 |(FAST-METHOD GENERIC-FUNCTION-PRETTY-ARGLIST (STANDARD-GENERIC-FUNCTION))|
+                |(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|
+                |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
+                |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+                |(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+                |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
                 |(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
+                |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|
+                |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
+                |(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
                 |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
-                |(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|
-                |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
                 |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
-                |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
-                |(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
+                |(FAST-METHOD CHANGE-CLASS (T SYMBOL))|
+                |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|
                 |(FAST-METHOD REMOVE-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
-                |(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
                 |(FAST-METHOD ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
-                |(FAST-METHOD INITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
+                |(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
                 |(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
-                |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (STANDARD-GENERIC-FUNCTION))|
-                |(FAST-METHOD REINITIALIZE-INSTANCE (STANDARD-METHOD))|
-                |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-                |(FAST-METHOD METHOD-FUNCTION (STANDARD-METHOD))|
-                |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (SYMBOL))|
-                |(FAST-METHOD METHOD-SPECIALIZERS (TRACED-METHOD))|
-                |(FAST-METHOD METHOD-LAMBDA-LIST (TRACED-METHOD))|
-                |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION (STANDARD-GENERIC-FUNCTION))|
-                |(FAST-METHOD METHOD-PRETTY-ARGLIST (STANDARD-METHOD))|
-                |(FAST-METHOD ACCESSOR-METHOD-SLOT-NAME (TRACED-METHOD))|
-                |(FAST-METHOD COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO (STANDARD-GENERIC-FUNCTION))|
-                |(FAST-METHOD METHOD-QUALIFIERS (TRACED-METHOD))|
-                |(FAST-METHOD FUNCTION-KEYWORDS (STANDARD-METHOD))|
-                |(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
                 |(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))|
-                |(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
-                |(FAST-METHOD CHANGE-CLASS (T SYMBOL))|
                 |(FAST-METHOD DOCUMENTATION (STANDARD-SLOT-DEFINITION))|
+                |(FAST-METHOD SLOT-DEFINITION-ALLOCATION (STRUCTURE-SLOT-DEFINITION))|
+                |(FAST-METHOD INITIALIZE-INTERNAL-SLOT-FUNCTIONS (EFFECTIVE-SLOT-DEFINITION))|
                 |(FAST-METHOD MAKE-INSTANCE (SYMBOL))|
+                |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
                 |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
-                |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
-                |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
-                |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|
-                |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
-                |(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
-                |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
-                |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
-                |(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
+                |(FAST-METHOD SLOT-VALUE-USING-CLASS (STRUCTURE-CLASS STRUCTURE-OBJECT STRUCTURE-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD SLOT-MAKUNBOUND-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD SLOT-BOUNDP-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD (SETF SLOT-VALUE-USING-CLASS) (T STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD SLOT-VALUE-USING-CLASS (STD-CLASS STANDARD-OBJECT STANDARD-EFFECTIVE-SLOT-DEFINITION))|
+                |(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
+                |(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
+                |(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|
+                |(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
+                |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
+                |(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
                 |(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
+                |(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
+                |(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|
+                |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
+                |(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
                 |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (BUILT-IN-CLASS))|
+                |(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
                 |(FAST-METHOD CLASS-DIRECT-SLOTS (BUILT-IN-CLASS))|
-                |(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
+                |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
+                |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
                 |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
-                |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
+                |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
                 |(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
-                |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
-                |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
-                |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|
-                |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
+                |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
                 |(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
-                |(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
-                |(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|
-                |(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
-                |(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
-                |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
-                |(FAST-METHOD CLASS-SLOTS (BUILT-IN-CLASS))|
-                |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
+                |(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
+                |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|
                 |(FAST-METHOD FINALIZE-INHERITANCE (STD-CLASS))|
-                |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS BUILT-IN-CLASS))|
-                |(FAST-METHOD SAME-SPECIALIZER-P (CLASS CLASS))|
-                |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
-                |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
-                |(FAST-METHOD VALIDATE-SUPERCLASS (FUNCALLABLE-STANDARD-CLASS STANDARD-CLASS))|
-                |(FAST-METHOD ALLOCATE-INSTANCE (FUNCALLABLE-STANDARD-CLASS))|
-                |(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
-                |(FAST-METHOD MAKE-INSTANCE (CLASS))|
-                |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
-                |(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
-                |(FAST-METHOD VALIDATE-SUPERCLASS (SLOT-CLASS FORWARD-REFERENCED-CLASS))|
-                |(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
+                |(FAST-METHOD FINALIZE-INHERITANCE (STRUCTURE-CLASS))|
+                |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
                 |(FAST-METHOD REINITIALIZE-INSTANCE :BEFORE (SLOT-CLASS))|
+                |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T PCL-CLASS))|
+                |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
+                |(FAST-METHOD SPECIALIZER-DIRECT-METHODS (CLASS))|
+                |(FAST-METHOD REMOVE-DIRECT-SUBCLASS (CLASS CLASS))|
+                |(FAST-METHOD ADD-DIRECT-SUBCLASS (CLASS CLASS))|
+                |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
+                |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
+                |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
+                |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
                 |(FAST-METHOD CLASS-PROTOTYPE (STRUCTURE-CLASS))|
                 |(FAST-METHOD CLASS-PROTOTYPE (STD-CLASS))|
+                |(FAST-METHOD CLASS-FINALIZED-P (PCL-CLASS))|
+                |(FAST-METHOD MAKE-INSTANCE (CLASS))|
                 |(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|
-                |(FAST-METHOD REINITIALIZE-INSTANCE :AFTER (SLOT-CLASS))|
+                |(FAST-METHOD ALLOCATE-INSTANCE (STANDARD-CLASS))|
+                |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
+                |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|
+                |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
                 CLASS-PREDICATE-NAME
                 |PCL::STRUCTURE-SLOT-DEFINITION class predicate|
                 |PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
@@ -1205,8 +1233,8 @@
                 |(WRITER PREDICATE-NAME)| |(WRITER READERS)|
                 |(READER WRITER-FUNCTION)| |(READER INITFUNCTION)|
                 INITIALIZE-INTERNAL-SLOT-FUNCTIONS
-                |SETF PCL SLOT-DEFINITION-TYPE| |(READER WRITERS)|
-                |(WRITER CLASS-PRECEDENCE-LIST)|
+                |SETF PCL SLOT-DEFINITION-TYPE|
+                |(WRITER CLASS-PRECEDENCE-LIST)| |(READER WRITERS)|
                 |(WRITER ACCESSOR-FLAGS)| |(READER INITFORM)|
                 METHOD-COMBINATION-P |(WRITER LOCATION)|
                 |(WRITER DOCUMENTATION)|
@@ -1220,11 +1248,11 @@
                 |(READER ALLOCATION)| |(WRITER SPECIALIZERS)|
                 |(CALL REAL-ENSURE-GF-USING-CLASS--NULL)|
                 |(WRITER IDENTITY-WITH-ONE-ARGUMENT)|
-                |(SETF METHOD-GENERIC-FUNCTION)|
-                |(WRITER PRETTY-ARGLIST)| LEGAL-SPECIALIZERS-P
-                |SETF PCL OBJECT-PLIST| |(WRITER DEFSTRUCT-FORM)|
-                |(READER FUNCTION)| |(READER GENERIC-FUNCTION)|
-                |(READER LAMBDA-LIST)| |(READER SLOT-DEFINITION)|
+                |(SETF METHOD-GENERIC-FUNCTION)| LEGAL-SPECIALIZERS-P
+                |(WRITER PRETTY-ARGLIST)| |SETF PCL OBJECT-PLIST|
+                |(WRITER DEFSTRUCT-FORM)| |(READER FUNCTION)|
+                |(READER GENERIC-FUNCTION)| |(READER LAMBDA-LIST)|
+                |(READER SLOT-DEFINITION)|
                 |PCL::CLASS-PROTOTYPE-SPECIALIZER class predicate|
                 |SETF PCL SLOT-DEFINITION-INITFORM|
                 |SETF PCL CLASS-DEFSTRUCT-FORM|
@@ -1245,16 +1273,17 @@
                 |SETF PCL SLOT-DEFINITION-ALLOCATION|
                 |SETF PCL SLOT-DEFINITION-INITFUNCTION|
                 |(WRITER SLOT-NAME)| |(BOUNDP NAME)|
-                |(READER FAST-FUNCTION)| |(WRITER ALLOCATION)|
+                |(WRITER ALLOCATION)| |(READER FAST-FUNCTION)|
                 |(READER METHOD-CLASS)| |(SETF OBJECT-PLIST)|
                 |(READER INTERNAL-WRITER-FUNCTION)|
                 |(READER INTERNAL-READER-FUNCTION)|
                 |(READER METHOD-COMBINATION)|
                 METHOD-COMBINATION-OPTIONS |(READER DIRECT-SLOTS)|
                 |(READER DIRECT-METHODS)|
-                |SETF PCL SLOT-DEFINITION-READERS| |(WRITER FUNCTION)|
-                |(WRITER GENERIC-FUNCTION)| |(READER BOUNDP-FUNCTION)|
-                |SETF PCL DOCUMENTATION| |(READER DIRECT-SUBCLASSES)|
+                |SETF PCL SLOT-DEFINITION-READERS|
+                |(READER BOUNDP-FUNCTION)| |(WRITER FUNCTION)|
+                |(WRITER GENERIC-FUNCTION)| |SETF PCL DOCUMENTATION|
+                |(READER DIRECT-SUBCLASSES)|
                 |(READER DIRECT-SUPERCLASSES)| |(WRITER LAMBDA-LIST)|
                 FUNCALLABLE-STANDARD-CLASS-P
                 |(FAST-WRITER-METHOD SLOT-OBJECT METHOD)|
@@ -1265,7 +1294,7 @@
                 |SETF PCL SLOT-VALUE-USING-CLASS|
                 |(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
                 |(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION DEFSTRUCT-ACCESSOR-SYMBOL)|
-                |(WRITER PROTOTYPE)| |(BOUNDP TYPE)| |(BOUNDP OBJECT)|
+                |(WRITER PROTOTYPE)| |(BOUNDP OBJECT)| |(BOUNDP TYPE)|
                 CLASS-CAN-PRECEDE-LIST |SETF PCL CLASS-DIRECT-SLOTS|
                 |SETF PCL CLASS-SLOTS| SLOT-ACCESSOR-FUNCTION
                 |(BOUNDP PLIST)|
@@ -1280,11 +1309,11 @@
                 |(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
                 |PCL::PLIST-MIXIN class predicate|
                 |(WRITER FAST-FUNCTION)| |(WRITER METHOD-CLASS)|
-                |(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)| GET-METHOD
+                |(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)|
                 |(WRITER INTERNAL-WRITER-FUNCTION)|
                 |(WRITER INTERNAL-READER-FUNCTION)|
-                |(WRITER METHOD-COMBINATION)| |(WRITER DIRECT-SLOTS)|
-                |(WRITER DIRECT-METHODS)|
+                |(WRITER METHOD-COMBINATION)| GET-METHOD
+                |(WRITER DIRECT-SLOTS)| |(WRITER DIRECT-METHODS)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT INITARGS)|
                 |(FAST-WRITER-METHOD SLOT-DEFINITION INITARGS)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT OPERATOR)|
@@ -1354,18 +1383,18 @@
                 |(FAST-READER-METHOD SLOT-DEFINITION READERS)|
                 |(FAST-READER-METHOD SLOT-OBJECT SPECIALIZERS)|
                 |(FAST-READER-METHOD STANDARD-METHOD SPECIALIZERS)|
+                |(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)|
+                |(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
                 |(FAST-READER-METHOD SPECIALIZER TYPE)|
                 |(FAST-READER-METHOD SLOT-OBJECT PROTOTYPE)|
                 |(FAST-READER-METHOD PCL-CLASS PROTOTYPE)|
-                |(FAST-READER-METHOD SLOT-DEFINITION TYPE)|
-                |(FAST-READER-METHOD SLOT-OBJECT TYPE)|
-                |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)|
-                |(FAST-READER-METHOD SHORT-METHOD-COMBINATION IDENTITY-WITH-ONE-ARGUMENT)|
-                |(FAST-READER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
                 |(FAST-READER-METHOD CLASS-EQ-SPECIALIZER OBJECT)|
                 |(FAST-READER-METHOD CLASS-PROTOTYPE-SPECIALIZER OBJECT)|
                 |(FAST-READER-METHOD SLOT-OBJECT OBJECT)|
                 |(FAST-READER-METHOD EQL-SPECIALIZER OBJECT)|
+                |(FAST-READER-METHOD SLOT-DEFINITION TYPE)|
+                |(FAST-READER-METHOD SLOT-OBJECT TYPE)|
+                |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION TYPE)|
                 |(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
                 |(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
                 |(FAST-READER-METHOD SLOT-OBJECT INITFORM)|
@@ -1387,11 +1416,11 @@
                 |(FAST-READER-METHOD SLOT-CLASS SLOTS)|
                 |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SLOTS)|
                 |(FAST-READER-METHOD SLOT-CLASS DIRECT-SLOTS)|
+                |(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
                 |(FAST-READER-METHOD SLOT-OBJECT METHODS)|
                 |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHODS)|
                 |(FAST-READER-METHOD SLOT-OBJECT OPTIONS)|
                 |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION OPTIONS)|
-                |(FAST-READER-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
                 |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
                 |(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
                 |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
@@ -1429,8 +1458,8 @@
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)|
-                |(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT OBJECT)|
+                |(FAST-BOUNDP-METHOD SLOT-OBJECT TYPE)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT INITFORM)|
                 |(SETF SLOT-VALUE-USING-CLASS)|
@@ -1456,10 +1485,10 @@
                 |(SETF SLOT-DEFINITION-TYPE)|
                 |(SETF SLOT-DEFINITION-INITFORM)|
                 |(BOUNDP INITIALIZE-INFO)|
-                |(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-METHODS)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT SLOTS)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SLOTS)|
+                |(FAST-BOUNDP-METHOD SLOT-OBJECT FROM-DEFCLASS-P)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT METHODS)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT OPTIONS)|
                 |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
@@ -1468,94 +1497,95 @@
                 |(BOUNDP INITARGS)| LONG-METHOD-COMBINATION-FUNCTION
                 GENERIC-FUNCTION-P
                 |PCL::SLOT-DEFINITION class predicate| |(READER NAME)|
-                |(READER CLASS)| |(FAST-METHOD SLOT-UNBOUND (T T T))|
-                |(FAST-METHOD (SETF DOCUMENTATION) (T T))|
-                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
-                |(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
-                |(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
-                |(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+                |(READER CLASS)|
+                |(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
+                |(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
+                |(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
+                |(FAST-METHOD DESCRIBE-OBJECT (T T))|
+                |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
+                |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
+                |(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
+                |(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+                |(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
+                |(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
                 |(FAST-METHOD REMOVE-NAMED-METHOD (T T))|
+                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
+                |(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
                 |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-METHOD T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
-                |(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
-                |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION SHORT-METHOD-COMBINATION T))|
                 |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-ACCESSOR-METHOD T))|
-                |(FAST-METHOD FIND-METHOD-COMBINATION (GENERIC-FUNCTION (EQL STANDARD) T))|
-                |(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
-                |(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
-                |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-                |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
+                |(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
+                |(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
                 |(FAST-METHOD LEGAL-SLOT-NAME-P (STANDARD-METHOD T))|
-                |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+                |(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
+                |(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+                |(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
+                |(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
+                |(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
+                |(FAST-METHOD PRINT-OBJECT (STANDARD-ACCESSOR-METHOD T))|
+                |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
+                |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-SLOT-DEFINITION T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
+                |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
+                |(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
                 |(FAST-METHOD PRINT-OBJECT (CLASS T))|
-                |(FAST-METHOD COMPUTE-APPLICABLE-METHODS (GENERIC-FUNCTION T))|
                 |(FAST-METHOD PRINT-OBJECT (T T))|
-                |(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-                |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD T))|
-                |(FAST-METHOD PRINT-OBJECT (GENERIC-FUNCTION T))|
+                |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
+                |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
                 |(FAST-METHOD MAP-DEPENDENTS (DEPENDENT-UPDATE-MIXIN T))|
                 |(FAST-METHOD REMOVE-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
-                |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (FUNCALLABLE-STANDARD-CLASS T))|
-                |(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
-                |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
-                |(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
-                |(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
-                |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
-                |(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
-                |(FAST-METHOD PRINT-OBJECT (STANDARD-METHOD-COMBINATION T))|
-                |(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
-                |(FAST-METHOD PRINT-OBJECT (SLOT-DEFINITION T))|
-                |(FAST-METHOD UPDATE-GF-DFUN (STD-CLASS T))|
+                |(FAST-METHOD ADD-DEPENDENT (DEPENDENT-UPDATE-MIXIN T))|
+                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (BUILT-IN-CLASS T))|
+                |(FAST-METHOD COMPATIBLE-META-CLASS-CHANGE-P (T T))|
                 |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STD-CLASS T))|
-                |(FAST-METHOD LEGAL-DOCUMENTATION-P (STANDARD-METHOD T))|
-                |(FAST-METHOD LEGAL-LAMBDA-LIST-P (STANDARD-METHOD T))|
-                |(FAST-METHOD LEGAL-SPECIALIZER-P (STANDARD-METHOD T))|
-                |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+                |(FAST-METHOD MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
                 |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
-                |(FAST-METHOD INFORM-TYPE-SYSTEM-ABOUT-CLASS (STRUCTURE-CLASS T))|
-                |(FAST-METHOD LEGAL-QUALIFIER-P (STANDARD-METHOD T))|
-                |(FAST-METHOD LEGAL-METHOD-FUNCTION-P (STANDARD-METHOD T))|
                 |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-CLASS T))|
-                |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+                |(FAST-METHOD REMOVE-BOUNDP-METHOD (SLOT-CLASS T))|
+                |(FAST-METHOD REMOVE-WRITER-METHOD (SLOT-CLASS T))|
+                |(FAST-METHOD REMOVE-READER-METHOD (SLOT-CLASS T))|
+                |(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
                 |(FAST-METHOD ADD-WRITER-METHOD (SLOT-CLASS T T))|
-                |(FAST-METHOD COMPUTE-EFFECTIVE-METHOD (GENERIC-FUNCTION LONG-METHOD-COMBINATION T))|
-                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-METHOD T))|
-                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
-                |(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+                |(FAST-METHOD WRITER-METHOD-CLASS (SLOT-CLASS T))|
                 |(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T T))|
-                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (STANDARD-GENERIC-FUNCTION T))|
-                |(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+                |(FAST-METHOD READER-METHOD-CLASS (SLOT-CLASS T))|
+                |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS :AROUND (STRUCTURE-CLASS T))|
+                |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (SLOT-CLASS T))|
+                |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+                |(FAST-METHOD EFFECTIVE-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+                |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
+                |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STD-CLASS T))|
+                |(FAST-METHOD DIRECT-SLOT-DEFINITION-CLASS (STRUCTURE-CLASS T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STRUCTURE-CLASS T))|
+                |(FAST-METHOD SHARED-INITIALIZE :BEFORE (CLASS T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STD-CLASS T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
                 |(FAST-METHOD SHARED-INITIALIZE :AFTER (CLASS-EQ-SPECIALIZER T))|
+                |(FAST-METHOD (SETF DOCUMENTATION) (T T))|
+                |(FAST-METHOD SHARED-INITIALIZE :AFTER (DOCUMENTATION-MIXIN T))|
+                |(FAST-METHOD COMPUTE-SLOT-ACCESSOR-INFO (EFFECTIVE-SLOT-DEFINITION T T))|
+                |(FAST-METHOD (SETF SLOT-ACCESSOR-STD-P) (T EFFECTIVE-SLOT-DEFINITION T))|
+                |(FAST-METHOD SLOT-ACCESSOR-STD-P (EFFECTIVE-SLOT-DEFINITION T))|
+                |(FAST-METHOD (SETF SLOT-ACCESSOR-FUNCTION) (T EFFECTIVE-SLOT-DEFINITION T))|
+                |(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
                 |(FAST-METHOD SHARED-INITIALIZE (SLOT-OBJECT T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (EQL-SPECIALIZER T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-SLOT-DEFINITION T))|
-                |(FAST-METHOD SHARED-INITIALIZE :AFTER (STANDARD-ACCESSOR-METHOD T))|
-                |(FAST-METHOD ADD-BOUNDP-METHOD (SLOT-CLASS T T))|
-                |(FAST-METHOD DESCRIBE-OBJECT (CLASS T))|
-                |(FAST-METHOD LEGAL-SPECIALIZERS-P (STANDARD-METHOD T))|
-                |(FAST-METHOD LEGAL-QUALIFIERS-P (STANDARD-METHOD T))|
+                |(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
                 |(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
-                |(FAST-METHOD DESCRIBE-OBJECT (T T))|
-                |(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
-                |(FAST-METHOD COMPUTE-EFFECTIVE-SLOT-DEFINITION (SLOT-CLASS T))|
-                |(FAST-METHOD DESCRIBE-OBJECT (SLOT-OBJECT T))|
-                |(FAST-METHOD DESCRIBE-OBJECT (STANDARD-GENERIC-FUNCTION T))|
-                |(FAST-METHOD COMPUTE-APPLICABLE-METHODS-USING-CLASSES (GENERIC-FUNCTION T))|
-                |(FAST-METHOD SLOT-ACCESSOR-FUNCTION (EFFECTIVE-SLOT-DEFINITION T))|
+                |(FAST-METHOD SLOT-UNBOUND (T T T))|
                 |(FAST-METHOD SLOT-MISSING (T T T T))|
-                |(FAST-METHOD UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
-                LEGAL-SLOT-NAME-P |(READER TYPE)| |(READER OBJECT)|
+                |(FAST-METHOD (SETF CLASS-SLOT-VALUE) (T STD-CLASS T))|
+                |(FAST-METHOD CLASS-SLOT-VALUE (STD-CLASS T))|
+                LEGAL-SLOT-NAME-P |(READER OBJECT)| |(READER TYPE)|
                 CLASS-WRAPPER |(READER PLIST)|
                 |(FAST-METHOD CLASS-PREDICATE-NAME (T))|
                 |(FAST-METHOD DOCUMENTATION (T))|
                 |(FAST-METHOD NO-APPLICABLE-METHOD (T))|
                 |(READER SLOTS)| |(WRITER NAME)| DEFINITION-SOURCE
                 |PCL::SLOT-OBJECT class predicate| DEFAULT-INITARGS
-                |(WRITER CLASS)| CLASS-SLOT-VALUE |(WRITER TYPE)|
-                |(WRITER OBJECT)|
+                |(WRITER CLASS)| CLASS-SLOT-VALUE |(WRITER OBJECT)|
+                |(WRITER TYPE)|
                 |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|
                 |(WRITER PLIST)| |(WRITER SLOTS)|
                 |PCL::DOCUMENTATION-MIXIN class predicate|
@@ -1595,10 +1625,10 @@
                 |COMMON-LISP::STANDARD-OBJECT class predicate|
                 |COMMON-LISP::BUILT-IN-CLASS class predicate|
                 |SETF PCL CLASS-SLOT-VALUE| |(SETF CLASS-SLOTS)|
-                |(SETF CLASS-DIRECT-SLOTS)| DO-STANDARD-DEFSETF-1
-                |(READER OPERATOR)| |(CALL REAL-GET-METHOD)|
-                |(CALL REAL-REMOVE-METHOD)| |(CALL REAL-ADD-METHOD)|
-                |(READER ARG-INFO)| METHOD-COMBINATION-TYPE
+                |(SETF CLASS-DIRECT-SLOTS)| |(READER OPERATOR)|
+                |(CALL REAL-GET-METHOD)| |(CALL REAL-REMOVE-METHOD)|
+                |(CALL REAL-ADD-METHOD)| |(READER ARG-INFO)|
+                METHOD-COMBINATION-TYPE
                 |(READER DEFSTRUCT-CONSTRUCTOR)|
                 |(INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
                 |(READER INITIALIZE-INFO)| |(WRITER WRAPPER)|
@@ -1607,8 +1637,8 @@
                 |(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)|
                 COMPUTE-SLOT-ACCESSOR-INFO |(READER INITARGS)|
                 |(WRITER CLASS-EQ-SPECIALIZER)|
-                STANDARD-BOUNDP-METHOD-P FDEFINE-CAREFULLY
-                |(SETF DOCUMENTATION)| RAW-INSTANCE-ALLOCATOR
+                STANDARD-BOUNDP-METHOD-P |(SETF DOCUMENTATION)|
+                RAW-INSTANCE-ALLOCATOR
                 |SETF PCL SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL|
                 |SETF PCL CLASS-INITIALIZE-INFO| |(WRITER OPERATOR)|
                 |(WRITER ARG-INFO)|
@@ -1621,8 +1651,9 @@
                 METHOD-COMBINATION-DOCUMENTATION
                 |SETF PCL SLOT-DEFINITION-INITARGS|
                 REMOVE-BOUNDP-METHOD ADD-NAMED-METHOD
+                |(WRITER INITARGS)|
                 |SETF PCL CLASS-DEFSTRUCT-CONSTRUCTOR|
-                |(WRITER INITARGS)| |(BOUNDP METHOD)|
+                |(BOUNDP METHOD)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)|
                 |(FAST-WRITER-METHOD CLASS NAME)|
                 |(FAST-WRITER-METHOD SLOT-DEFINITION NAME)|
@@ -1668,11 +1699,11 @@
                 |(FAST-WRITER-METHOD SLOT-OBJECT READERS)|
                 |(FAST-WRITER-METHOD SLOT-DEFINITION READERS)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT SPECIALIZERS)|
+                |(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT PROTOTYPE)|
+                |(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
                 |(FAST-WRITER-METHOD SLOT-DEFINITION TYPE)|
                 |(FAST-WRITER-METHOD SLOT-OBJECT TYPE)|
-                |(FAST-WRITER-METHOD SLOT-OBJECT IDENTITY-WITH-ONE-ARGUMENT)|
-                |(FAST-WRITER-METHOD SLOT-OBJECT OBJECT)|
                 REMOVE-NAMED-METHOD
                 |(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
                 |(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
@@ -1725,6 +1756,5 @@
                 ENSURE-CLASS-USING-CLASS NO-APPLICABLE-METHOD
                 SLOT-DEFINITION-WRITERS
                 COMPUTE-APPLICABLE-METHODS-USING-CLASSES
-                CLASS-PRECEDENCE-LIST DISASSEMBLE DESCRIBE-OBJECT
-                COMPILE))
-  (SETF (GET V 'SYSTEM::PROCLAIMED-CLOSURE) T)) 
+                CLASS-PRECEDENCE-LIST DESCRIBE-OBJECT))
+  (SETF (GET V 'COMPILER::PROCLAIMED-CLOSURE) T))