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

(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)|
                |(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SUBCLASSES)|
                |(FAST-WRITER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
                ADD-READER-METHOD
                SHORT-COMBINATION-IDENTITY-WITH-ONE-ARGUMENT
                REMOVE-READER-METHOD |LISP::T class predicate|
                EQL-SPECIALIZER-P |(SETF GENERIC-FUNCTION-NAME)|
                OBJECT-PLIST SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL
                |PCL::STANDARD-OBJECT class predicate|
                |PCL::STANDARD-SLOT-DEFINITION class predicate|
                |PCL::STANDARD-DIRECT-SLOT-DEFINITION class predicate|
                |PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION class predicate|
                |PCL::STANDARD-METHOD-COMBINATION class predicate|
                |(FAST-READER-METHOD SLOT-OBJECT METHOD)|
                |PCL::BUILT-IN-CLASS class predicate| SPECIALIZER-TYPE
                |LISP::RATIO class predicate|
                |LISP::RATIONAL class predicate| GF-DFUN-STATE
                |(SETF GENERIC-FUNCTION-METHOD-CLASS)|
                |(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-ACCESSOR-SYMBOL)|
                |(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION DEFSTRUCT-ACCESSOR-SYMBOL)|
                |(SETF GENERIC-FUNCTION-METHOD-COMBINATION)|
                CLASS-DEFSTRUCT-CONSTRUCTOR
                |(FAST-READER-METHOD SLOT-OBJECT SOURCE)|
                |(FAST-READER-METHOD DEFINITION-SOURCE-MIXIN SOURCE)|
                METHOD-FAST-FUNCTION |(SETF GENERIC-FUNCTION-METHODS)|
                |(SETF GF-PRETTY-ARGLIST)|
                |(FAST-READER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
                |(FAST-READER-METHOD SLOT-CLASS INITIALIZE-INFO)|
                |(FAST-READER-METHOD SLOT-OBJECT ARG-INFO)|
                |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
                SPECIALIZERP EXACT-CLASS-SPECIALIZER-P
                |(FAST-READER-METHOD SLOT-OBJECT WRAPPER)|
                |(FAST-READER-METHOD PCL-CLASS WRAPPER)|
                |(FAST-READER-METHOD SLOT-OBJECT INITARGS)|
                |(FAST-READER-METHOD SLOT-DEFINITION INITARGS)|
                |(FAST-READER-METHOD SHORT-METHOD-COMBINATION OPERATOR)|
                |(FAST-READER-METHOD SLOT-OBJECT OPERATOR)|
                |(FAST-READER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
                |(FAST-READER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
                |LISP::CHARACTER class predicate|
                COMPATIBLE-META-CLASS-CHANGE-P
                |LISP::SEQUENCE class predicate|
                |(FAST-READER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
                |(FAST-READER-METHOD CLASS CLASS-EQ-SPECIALIZER)|
                |(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)|
                SPECIALIZER-CLASS |(BOUNDP PRETTY-ARGLIST)|
                |PCL::PCL-CLASS class predicate|
                |PCL::STD-CLASS class predicate|
                |(BOUNDP DEFSTRUCT-FORM)|
                |(SETF SLOT-DEFINITION-DEFSTRUCT-ACCESSOR-SYMBOL)|
                CLASS-EQ-SPECIALIZER-P
                |(FAST-BOUNDP-METHOD SLOT-OBJECT SOURCE)| SLOTS-FETCHER
                |(SETF SLOT-ACCESSOR-STD-P)| REMOVE-WRITER-METHOD
                |(BOUNDP WRITER-FUNCTION)| |(BOUNDP INITFUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT INITIALIZE-INFO)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT ARG-INFO)|
                STRUCTURE-CLASS-P |(BOUNDP WRITERS)|
                |(BOUNDP INITFORM)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT WRAPPER)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT INITARGS)|
                |LISP::BIT-VECTOR class predicate|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
                UPDATE-CONSTRUCTORS |(BOUNDP SLOT-NAME)|
                |(SETF SLOT-DEFINITION-INITARGS)| |(BOUNDP ALLOCATION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
                DOCUMENTATION |(BOUNDP FUNCTION)|
                |(BOUNDP GENERIC-FUNCTION)| |(BOUNDP LAMBDA-LIST)|
                METHOD-PRETTY-ARGLIST |(BOUNDP SLOT-DEFINITION)|
                |LISP::ARRAY class predicate|
                |(BOUNDP CAN-PRECEDE-LIST)| |(BOUNDP PROTOTYPE)|
                CLASS-EQ-SPECIALIZER INFORM-TYPE-SYSTEM-ABOUT-CLASS
                |PCL::DEFINITION-SOURCE-MIXIN class predicate|
                |(BOUNDP DFUN-STATE)| |(BOUNDP FROM-DEFCLASS-P)|
                |(READER METHOD)|
                |(CALL STANDARD-COMPUTE-EFFECTIVE-METHOD)|
                |(BOUNDP FAST-FUNCTION)|
                |LISP::COMPLEX class predicate| |(BOUNDP METHOD-CLASS)|
                |(READER SOURCE)| |(BOUNDP INTERNAL-WRITER-FUNCTION)|
                |(BOUNDP INTERNAL-READER-FUNCTION)|
                |(BOUNDP METHOD-COMBINATION)| ACCESSOR-METHOD-CLASS
                |(BOUNDP DIRECT-SLOTS)| |(BOUNDP DIRECT-METHODS)|
                |(BOUNDP BOUNDP-FUNCTION)| |(BOUNDP DIRECT-SUBCLASSES)|
                |(BOUNDP DIRECT-SUPERCLASSES)| |(BOUNDP METHODS)|
                |(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 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS (STANDARD-OBJECT STANDARD-OBJECT))|
                |(FAST-METHOD REINITIALIZE-INSTANCE (SLOT-OBJECT))|
                |(FAST-METHOD INITIALIZE-INSTANCE (SLOT-OBJECT))|
                |(FAST-METHOD SPECIALIZER-CLASS (EQL-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
                |LISP::STRING class predicate|
                |(FAST-METHOD (SETF DOCUMENTATION) (T DOCUMENTATION-MIXIN))|
                |(FAST-METHOD DOCUMENTATION (DOCUMENTATION-MIXIN))|
                |PCL::METAOBJECT class predicate|
                |(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 ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
                |(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 ADD-DIRECT-METHOD (SPECIALIZER-WITH-OBJECT METHOD))|
                |(FAST-METHOD REMOVE-DIRECT-METHOD (CLASS METHOD))|
                |(FAST-METHOD ADD-DIRECT-METHOD (CLASS METHOD))|
                |(FAST-METHOD (SETF DOCUMENTATION) (T STANDARD-SLOT-DEFINITION))|
                |(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 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 CHANGE-CLASS (STANDARD-OBJECT FUNCALLABLE-STANDARD-CLASS))|
                |(FAST-METHOD CHANGE-CLASS (STANDARD-OBJECT STANDARD-CLASS))|
                |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
                |(FAST-METHOD VALIDATE-SUPERCLASS (CLASS CLASS))|
                |(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
                |(FAST-METHOD COMPUTE-SLOTS (STRUCTURE-CLASS))|
                |(FAST-METHOD COMPUTE-SLOTS :AROUND (STD-CLASS))|
                |(FAST-METHOD COMPUTE-SLOTS (STD-CLASS))|
                |(FAST-METHOD COMPUTE-DEFAULT-INITARGS (SLOT-CLASS))|
                |(FAST-METHOD FINALIZE-INHERITANCE (STD-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 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-OBJECT class predicate|
                |PCL::STRUCTURE-SLOT-DEFINITION class predicate|
                |PCL::STRUCTURE-DIRECT-SLOT-DEFINITION class predicate|
                |PCL::STRUCTURE-EFFECTIVE-SLOT-DEFINITION class predicate|
                |LISP::SYMBOL class predicate| CLASSP
                |PCL::EFFECTIVE-SLOT-DEFINITION class predicate|
                |(COMBINED-METHOD SHARED-INITIALIZE)|
                LEGAL-QUALIFIERS-P ADD-BOUNDP-METHOD
                LEGAL-LAMBDA-LIST-P |LISP::VECTOR class predicate|
                |SETF PCL GENERIC-FUNCTION-NAME|
                |(READER READER-FUNCTION)| |(READER PREDICATE-NAME)|
                |(READER READERS)| DESCRIBE-OBJECT
                |(READER CLASS-PRECEDENCE-LIST)|
                |(READER ACCESSOR-FLAGS)| |(READER LOCATION)|
                |(READER DOCUMENTATION)| CLASS-INITIALIZE-INFO
                |(SETF CLASS-SLOT-VALUE)| MAKE-WRITER-METHOD-FUNCTION
                |SETF PCL GF-DFUN-STATE|
                |(READER INCOMPATIBLE-SUPERCLASS-LIST)|
                |(READER SPECIALIZERS)|
                |(READER IDENTITY-WITH-ONE-ARGUMENT)|
                |(SETF CLASS-INITIALIZE-INFO)|
                |(READER PRETTY-ARGLIST)| |(READER DEFSTRUCT-FORM)|
                |SETF PCL SLOT-DEFINITION-NAME| |SETF PCL CLASS-NAME|
                |(WRITER READER-FUNCTION)|
                |(SETF CLASS-DEFSTRUCT-CONSTRUCTOR)|
                |(WRITER PREDICATE-NAME)| |(WRITER READERS)|
                |(READER WRITER-FUNCTION)| |(READER INITFUNCTION)|
                INITIALIZE-INTERNAL-SLOT-FUNCTIONS
                |SETF PCL SLOT-DEFINITION-TYPE|
                |(WRITER CLASS-PRECEDENCE-LIST)| |(READER WRITERS)|
                |(WRITER ACCESSOR-FLAGS)| |(READER INITFORM)|
                METHOD-COMBINATION-P |(WRITER LOCATION)|
                |(WRITER DOCUMENTATION)|
                |(CALL REAL-ENSURE-GF-USING-CLASS--GENERIC-FUNCTION)|
                |SETF PCL GENERIC-FUNCTION-METHODS|
                |SETF PCL GENERIC-FUNCTION-METHOD-COMBINATION|
                |SETF PCL METHOD-GENERIC-FUNCTION| |(READER SLOT-NAME)|
                |(WRITER INCOMPATIBLE-SUPERCLASS-LIST)|
                |SETF PCL SLOT-ACCESSOR-STD-P|
                |(CALL REAL-MAKE-METHOD-INITARGS-FORM)|
                |(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| |LISP::FLOAT class predicate|
                |(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|
                |(READER CAN-PRECEDE-LIST)|
                |SETF PCL GENERIC-FUNCTION-METHOD-CLASS|
                |(READER PROTOTYPE)| |(WRITER WRITER-FUNCTION)|
                |(WRITER INITFUNCTION)| |(WRITER WRITERS)|
                SLOT-ACCESSOR-STD-P |(WRITER INITFORM)|
                |(READER DFUN-STATE)| |(READER FROM-DEFCLASS-P)|
                |SETF PCL GF-PRETTY-ARGLIST|
                |SETF PCL SLOT-ACCESSOR-FUNCTION|
                |SETF PCL SLOT-DEFINITION-LOCATION|
                |SETF PCL SLOT-DEFINITION-READER-FUNCTION|
                |SETF PCL SLOT-DEFINITION-WRITER-FUNCTION|
                |SETF PCL SLOT-DEFINITION-BOUNDP-FUNCTION|
                |SETF PCL SLOT-DEFINITION-INTERNAL-READER-FUNCTION|
                |SETF PCL SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION|
                |SETF PCL SLOT-DEFINITION-ALLOCATION|
                |SETF PCL SLOT-DEFINITION-INITFUNCTION|
                |(WRITER SLOT-NAME)| |(BOUNDP NAME)|
                |(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|
                |(READER BOUNDP-FUNCTION)| |(WRITER FUNCTION)|
                |(WRITER GENERIC-FUNCTION)|
                |(READER DIRECT-SUBCLASSES)|
                |(READER DIRECT-SUPERCLASSES)| |SETF PCL DOCUMENTATION|
                |(WRITER LAMBDA-LIST)| |LISP::LIST class predicate|
                FUNCALLABLE-STANDARD-CLASS-P
                |(FAST-WRITER-METHOD SLOT-OBJECT METHOD)|
                |(BOUNDP CLASS)| |(WRITER SLOT-DEFINITION)|
                |(READER METHODS)| |(READER OPTIONS)|
                |(WRITER CAN-PRECEDE-LIST)|
                |SETF PCL SLOT-DEFINITION-CLASS|
                |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 OBJECT)| |(BOUNDP TYPE)|
                CLASS-CAN-PRECEDE-LIST |SETF PCL CLASS-DIRECT-SLOTS|
                |SETF PCL CLASS-SLOTS| SLOT-ACCESSOR-FUNCTION
                |(BOUNDP PLIST)|
                |SETF PCL CLASS-INCOMPATIBLE-SUPERCLASS-LIST|
                |SETF PCL SLOT-DEFINITION-WRITERS|
                |(FAST-WRITER-METHOD SLOT-OBJECT SOURCE)|
                |(WRITER DFUN-STATE)| |(WRITER FROM-DEFCLASS-P)|
                |(BOUNDP SLOTS)| SLOT-CLASS-P
                MAKE-READER-METHOD-FUNCTION LEGAL-METHOD-FUNCTION-P
                |(FAST-WRITER-METHOD SLOT-OBJECT INITIALIZE-INFO)|
                |(FAST-WRITER-METHOD SLOT-CLASS INITIALIZE-INFO)|
                |(FAST-WRITER-METHOD SLOT-OBJECT ARG-INFO)|
                |PCL::PLIST-MIXIN class predicate|
                |(WRITER FAST-FUNCTION)| |(WRITER METHOD-CLASS)|
                |(FAST-WRITER-METHOD SLOT-OBJECT WRAPPER)|
                |(WRITER INTERNAL-WRITER-FUNCTION)|
                |(WRITER INTERNAL-READER-FUNCTION)|
                |(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)|
                |(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-CONSTRUCTOR)|
                |(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-CONSTRUCTOR)|
                |(WRITER BOUNDP-FUNCTION)| |(WRITER DIRECT-SUBCLASSES)|
                |(WRITER DIRECT-SUPERCLASSES)|
                |(FAST-WRITER-METHOD SLOT-OBJECT CLASS-EQ-SPECIALIZER)|
                |(WRITER METHODS)| |(WRITER OPTIONS)|
                SHORT-METHOD-COMBINATION-P GF-ARG-INFO
                SPECIALIZER-METHOD-TABLE MAKE-METHOD-INITARGS-FORM
                CLASS-DEFSTRUCT-FORM |LISP::INTEGER class predicate|
                |(FAST-READER-METHOD SLOT-OBJECT PREDICATE-NAME)|
                |(FAST-READER-METHOD CLASS PREDICATE-NAME)|
                |(FAST-READER-METHOD CLASS NAME)|
                |(FAST-READER-METHOD SLOT-DEFINITION NAME)|
                |(FAST-READER-METHOD SLOT-OBJECT SLOT-NAME)|
                |(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-NAME)|
                |(FAST-READER-METHOD SLOT-OBJECT DFUN-STATE)|
                |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
                |(FAST-READER-METHOD SLOT-OBJECT NAME)|
                |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
                GF-PRETTY-ARGLIST SAME-SPECIALIZER-P
                SLOT-DEFINITION-BOUNDP-FUNCTION
                SLOT-DEFINITION-WRITER-FUNCTION
                SLOT-DEFINITION-READER-FUNCTION
                SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION
                SLOT-DEFINITION-INTERNAL-READER-FUNCTION
                |(FAST-READER-METHOD SLOT-OBJECT CLASS)|
                |(FAST-READER-METHOD SLOT-DEFINITION CLASS)|
                |(FAST-READER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
                |(FAST-READER-METHOD SLOT-OBJECT METHOD-CLASS)|
                |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
                |(FAST-READER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
                |(FAST-READER-METHOD TRACED-METHOD FUNCTION)|
                |(FAST-READER-METHOD LONG-METHOD-COMBINATION FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT INITFUNCTION)|
                |(FAST-READER-METHOD SLOT-DEFINITION INITFUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT ALLOCATION)|
                |(FAST-READER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
                |(FAST-READER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
                |(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
                |(FAST-READER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
                |(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
                |(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT READER-FUNCTION)|
                |(FAST-READER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT LOCATION)|
                |(FAST-READER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
                |(FAST-READER-METHOD SLOT-OBJECT FAST-FUNCTION)|
                |(FAST-READER-METHOD STANDARD-METHOD FAST-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
                |(FAST-READER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
                |(FAST-READER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
                |(FAST-READER-METHOD STANDARD-ACCESSOR-METHOD SLOT-DEFINITION)|
                |(FAST-READER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
                |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
                |(FAST-READER-METHOD SLOT-OBJECT DOCUMENTATION)|
                |(FAST-READER-METHOD STANDARD-METHOD-COMBINATION DOCUMENTATION)|
                |(FAST-READER-METHOD SLOT-OBJECT WRITERS)|
                |(FAST-READER-METHOD SLOT-DEFINITION WRITERS)|
                |(FAST-READER-METHOD SLOT-OBJECT READERS)|
                |(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 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)|
                |(FAST-READER-METHOD SLOT-DEFINITION INITFORM)|
                |(FAST-READER-METHOD SLOT-OBJECT PLIST)|
                |(FAST-READER-METHOD PLIST-MIXIN PLIST)|
                |(FAST-READER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
                |(FAST-READER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
                |(FAST-READER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
                |(FAST-READER-METHOD PCL-CLASS CAN-PRECEDE-LIST)|
                |(FAST-READER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
                |(FAST-READER-METHOD PCL-CLASS CLASS-PRECEDENCE-LIST)|
                |(FAST-READER-METHOD SLOT-OBJECT LAMBDA-LIST)|
                |(FAST-READER-METHOD STANDARD-METHOD LAMBDA-LIST)|
                |(FAST-READER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
                |(FAST-READER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
                |(FAST-READER-METHOD SLOT-OBJECT DIRECT-METHODS)|
                |(FAST-READER-METHOD SLOT-OBJECT SLOTS)|
                |(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 DIRECT-SUBCLASSES)|
                |(FAST-READER-METHOD CLASS DIRECT-SUBCLASSES)|
                |(FAST-READER-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
                |(FAST-READER-METHOD CLASS DIRECT-SUPERCLASSES)|
                SLOT-DEFINITION-CLASS EQL-SPECIALIZER-OBJECT
                |PCL::DIRECT-SLOT-DEFINITION class predicate|
                CLASS-CONSTRUCTORS |(BOUNDP WRAPPER)| SLOTS-TO-INSPECT
                |(FAST-BOUNDP-METHOD SLOT-OBJECT PREDICATE-NAME)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-NAME)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT DFUN-STATE)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT NAME)|
                |(BOUNDP DEFSTRUCT-ACCESSOR-SYMBOL)|
                SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
                |(BOUNDP CLASS-EQ-SPECIALIZER)|
                |(SETF SLOT-DEFINITION-NAME)| ADD-WRITER-METHOD
                |(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-CLASS)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT INITFUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT ALLOCATION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT WRITER-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT READER-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT LOCATION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT FAST-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT SLOT-DEFINITION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT METHOD-COMBINATION)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT DOCUMENTATION)|
                |(BOUNDP OPERATOR)| |(BOUNDP ARG-INFO)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT WRITERS)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT READERS)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT SPECIALIZERS)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT PROTOTYPE)|
                |(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)|
                |(SETF SLOT-DEFINITION-CLASS)|
                |(SETF SLOT-ACCESSOR-FUNCTION)|
                |(SETF SLOT-DEFINITION-INITFUNCTION)|
                |(SETF SLOT-DEFINITION-ALLOCATION)|
                |(SETF SLOT-DEFINITION-INTERNAL-WRITER-FUNCTION)|
                |(SETF SLOT-DEFINITION-INTERNAL-READER-FUNCTION)|
                |(SETF SLOT-DEFINITION-BOUNDP-FUNCTION)|
                |(SETF SLOT-DEFINITION-WRITER-FUNCTION)|
                |(SETF SLOT-DEFINITION-READER-FUNCTION)|
                |(SETF SLOT-DEFINITION-LOCATION)|
                |(BOUNDP DEFSTRUCT-CONSTRUCTOR)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT PLIST)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT LAMBDA-LIST)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
                |(SETF SLOT-DEFINITION-WRITERS)|
                |(SETF SLOT-DEFINITION-READERS)|
                |(SETF SLOT-DEFINITION-TYPE)|
                |(SETF SLOT-DEFINITION-INITFORM)|
                |(BOUNDP INITIALIZE-INFO)|
                |(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)|
                |(FAST-BOUNDP-METHOD SLOT-OBJECT DIRECT-SUPERCLASSES)|
                |(FAST-INTERNAL-READER-METHOD STANDARD-GENERIC-FUNCTION ARG-INFO)|
                |(BOUNDP INITARGS)| LONG-METHOD-COMBINATION-FUNCTION
                GENERIC-FUNCTION-P
                |PCL::SLOT-DEFINITION class predicate|
                |LISP::NULL class predicate| |(READER NAME)|
                |(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 :BEFORE (STANDARD-ACCESSOR-METHOD 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 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 PRINT-OBJECT (T 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 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 MAKE-BOUNDP-METHOD-FUNCTION (SLOT-CLASS T))|
                |(FAST-METHOD MAKE-WRITER-METHOD-FUNCTION (SLOT-CLASS T))|
                |(FAST-METHOD MAKE-READER-METHOD-FUNCTION (SLOT-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 WRITER-METHOD-CLASS (SLOT-CLASS T))|
                |(FAST-METHOD ADD-READER-METHOD (SLOT-CLASS T 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 UPDATE-INSTANCE-FOR-REDEFINED-CLASS (STANDARD-OBJECT T T T))|
                |(FAST-METHOD DEFAULT-INITARGS (SLOT-CLASS T))|
                |(FAST-METHOD SLOT-UNBOUND (T T T))|
                |(FAST-METHOD SLOT-MISSING (T T T T))|
                |(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 OBJECT)|
                |(WRITER TYPE)|
                |(FAST-METHOD ENSURE-CLASS-USING-CLASS (T NULL))|
                |(WRITER PLIST)| |(WRITER SLOTS)|
                |PCL::DOCUMENTATION-MIXIN class predicate|
                FORWARD-REFERENCED-CLASS-P GF-FAST-METHOD-FUNCTION-P
                LEGAL-QUALIFIER-P METHOD-P
                |PCL::SPECIALIZER-WITH-OBJECT class predicate|
                CLASS-SLOT-CELLS
                |(COMBINED-METHOD INITIALIZE-INSTANCE)|
                |(COMBINED-METHOD REINITIALIZE-INSTANCE)|
                STANDARD-ACCESSOR-METHOD-P |(SETF CLASS-NAME)|
                STANDARD-GENERIC-FUNCTION-P STANDARD-READER-METHOD-P
                STANDARD-METHOD-P |(READER WRAPPER)|
                |(READER DEFSTRUCT-ACCESSOR-SYMBOL)|
                |(READER CLASS-EQ-SPECIALIZER)|
                COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS
                COMPUTE-DEFAULT-INITARGS |(SETF CLASS-DEFSTRUCT-FORM)|
                |(CALL REAL-MAKE-METHOD-LAMBDA)|
                |(SETF CLASS-INCOMPATIBLE-SUPERCLASS-LIST)|
                |SETF PCL CLASS-SLOT-VALUE| |(SETF CLASS-SLOTS)|
                |(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)|
                STANDARD-CLASS-P |LISP::NUMBER class predicate|
                LEGAL-SPECIALIZER-P
                |PCL::LONG-METHOD-COMBINATION class predicate|
                |(WRITER DEFSTRUCT-ACCESSOR-SYMBOL)|
                COMPUTE-SLOT-ACCESSOR-INFO |(READER INITARGS)|
                |(WRITER CLASS-EQ-SPECIALIZER)|
                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)|
                COMPUTE-DISCRIMINATING-FUNCTION-ARGLIST-INFO
                STANDARD-WRITER-METHOD-P
                CLASS-INCOMPATIBLE-SUPERCLASS-LIST
                |(WRITER DEFSTRUCT-CONSTRUCTOR)|
                |PCL::TRACED-METHOD class predicate| WRAPPER-FETCHER
                MAKE-A-METHOD |(WRITER INITIALIZE-INFO)|
                METHOD-COMBINATION-DOCUMENTATION
                |SETF PCL SLOT-DEFINITION-INITARGS|
                REMOVE-BOUNDP-METHOD ADD-NAMED-METHOD
                |LISP::CONS class predicate| |(WRITER INITARGS)|
                |SETF PCL CLASS-DEFSTRUCT-CONSTRUCTOR|
                |(BOUNDP METHOD)|
                |(FAST-WRITER-METHOD SLOT-OBJECT PREDICATE-NAME)|
                |(FAST-WRITER-METHOD CLASS NAME)|
                |(FAST-WRITER-METHOD SLOT-DEFINITION NAME)|
                |(FAST-WRITER-METHOD SLOT-OBJECT SLOT-NAME)|
                |(FAST-WRITER-METHOD SLOT-OBJECT DFUN-STATE)|
                |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION DFUN-STATE)|
                |(FAST-WRITER-METHOD SLOT-OBJECT NAME)|
                |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION NAME)|
                |(BOUNDP SOURCE)| |(SETF GF-DFUN-STATE)|
                SHORT-COMBINATION-OPERATOR
                |(FAST-WRITER-METHOD SLOT-OBJECT CLASS)|
                |(FAST-WRITER-METHOD SLOT-DEFINITION CLASS)|
                |(FAST-WRITER-METHOD SLOT-OBJECT ACCESSOR-FLAGS)|
                |(FAST-WRITER-METHOD SLOT-OBJECT METHOD-CLASS)|
                |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-CLASS)|
                |(FAST-WRITER-METHOD TRACED-METHOD GENERIC-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT INITFUNCTION)|
                |(FAST-WRITER-METHOD SLOT-DEFINITION INITFUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT ALLOCATION)|
                |(FAST-WRITER-METHOD STANDARD-SLOT-DEFINITION ALLOCATION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-WRITER-FUNCTION)|
                |(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-WRITER-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT INTERNAL-READER-FUNCTION)|
                |(FAST-WRITER-METHOD STRUCTURE-SLOT-DEFINITION INTERNAL-READER-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT BOUNDP-FUNCTION)|
                |(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION BOUNDP-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT WRITER-FUNCTION)|
                |(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION WRITER-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT READER-FUNCTION)|
                |(FAST-WRITER-METHOD EFFECTIVE-SLOT-DEFINITION READER-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT LOCATION)|
                |(FAST-WRITER-METHOD STANDARD-EFFECTIVE-SLOT-DEFINITION LOCATION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT FAST-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT GENERIC-FUNCTION)|
                |(FAST-WRITER-METHOD STANDARD-METHOD GENERIC-FUNCTION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT SLOT-DEFINITION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT METHOD-COMBINATION)|
                |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION METHOD-COMBINATION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT DOCUMENTATION)|
                |(FAST-WRITER-METHOD SLOT-OBJECT WRITERS)|
                |(FAST-WRITER-METHOD SLOT-DEFINITION WRITERS)|
                |(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)|
                REMOVE-NAMED-METHOD
                |(FAST-WRITER-METHOD SLOT-OBJECT DEFSTRUCT-FORM)|
                |(FAST-WRITER-METHOD STRUCTURE-CLASS DEFSTRUCT-FORM)|
                |(FAST-WRITER-METHOD SLOT-OBJECT INITFORM)|
                |(FAST-WRITER-METHOD SLOT-DEFINITION INITFORM)|
                |(FAST-WRITER-METHOD SLOT-OBJECT PLIST)|
                |(FAST-WRITER-METHOD PLIST-MIXIN PLIST)|
                |(FAST-WRITER-METHOD SLOT-OBJECT INCOMPATIBLE-SUPERCLASS-LIST)|
                |(FAST-WRITER-METHOD PCL-CLASS INCOMPATIBLE-SUPERCLASS-LIST)|
                |(FAST-WRITER-METHOD SLOT-OBJECT CAN-PRECEDE-LIST)|
                |(FAST-WRITER-METHOD SLOT-OBJECT CLASS-PRECEDENCE-LIST)|
                |(FAST-WRITER-METHOD SLOT-OBJECT LAMBDA-LIST)|
                |(FAST-WRITER-METHOD SLOT-OBJECT PRETTY-ARGLIST)|
                |(FAST-WRITER-METHOD STANDARD-GENERIC-FUNCTION PRETTY-ARGLIST)|
                LEGAL-DOCUMENTATION-P CLASS-DIRECT-SUPERCLASSES
                CLASS-DIRECT-SUBCLASSES CLASS-DIRECT-DEFAULT-INITARGS
                SLOT-DEFINITION-READERS SLOT-VALUE-USING-CLASS
                COMPUTE-APPLICABLE-METHODS CLASS-NAME CLASS-PROTOTYPE
                READER-METHOD-CLASS REMOVE-METHOD
                SLOT-DEFINITION-INITFORM
                UPDATE-INSTANCE-FOR-REDEFINED-CLASS
                UPDATE-INSTANCE-FOR-DIFFERENT-CLASS CHANGE-CLASS
                METHOD-FUNCTION DIRECT-SLOT-DEFINITION-CLASS
                MAKE-METHOD-LAMBDA EFFECTIVE-SLOT-DEFINITION-CLASS
                CLASS-SLOTS COMPUTE-SLOTS SLOT-DEFINITION-NAME
                FINALIZE-INHERITANCE GENERIC-FUNCTION-LAMBDA-LIST
                CLASS-DIRECT-SLOTS CLASS-DEFAULT-INITARGS
                COMPUTE-DISCRIMINATING-FUNCTION CLASS-FINALIZED-P
                GENERIC-FUNCTION-NAME REMOVE-DEPENDENT
                COMPUTE-CLASS-PRECEDENCE-LIST ADD-DEPENDENT
                SLOT-BOUNDP-USING-CLASS ACCESSOR-METHOD-SLOT-DEFINITION
                SHARED-INITIALIZE ADD-DIRECT-METHOD
                SLOT-DEFINITION-LOCATION SLOT-DEFINITION-INITFUNCTION
                SLOT-DEFINITION-ALLOCATION ADD-METHOD
                GENERIC-FUNCTION-METHOD-CLASS METHOD-SPECIALIZERS
                SLOT-DEFINITION-INITARGS WRITER-METHOD-CLASS
                ADD-DIRECT-SUBCLASS SPECIALIZER-DIRECT-METHODS
                GENERIC-FUNCTION-METHOD-COMBINATION ALLOCATE-INSTANCE
                COMPUTE-EFFECTIVE-METHOD SLOT-DEFINITION-TYPE
                SLOT-UNBOUND INITIALIZE-INSTANCE FUNCTION-KEYWORDS
                REINITIALIZE-INSTANCE VALIDATE-SUPERCLASS
                GENERIC-FUNCTION-METHODS REMOVE-DIRECT-METHOD
                METHOD-LAMBDA-LIST MAKE-INSTANCE
                COMPUTE-EFFECTIVE-SLOT-DEFINITION PRINT-OBJECT
                METHOD-QUALIFIERS METHOD-GENERIC-FUNCTION
                REMOVE-DIRECT-SUBCLASS MAKE-INSTANCES-OBSOLETE
                SLOT-MAKUNBOUND-USING-CLASS
                ENSURE-GENERIC-FUNCTION-USING-CLASS SLOT-MISSING
                MAP-DEPENDENTS UPDATE-DEPENDENT FIND-METHOD-COMBINATION
                ENSURE-CLASS-USING-CLASS NO-APPLICABLE-METHOD
                SLOT-DEFINITION-WRITERS
                COMPUTE-APPLICABLE-METHODS-USING-CLASSES
                CLASS-PRECEDENCE-LIST))
  (SETF (GET V 'COMPILER::PROCLAIMED-CLOSURE) T)) 
