
(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 T) *)
            |(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))|
            |(FAST-METHOD ALLOCATE-INSTANCE (STRUCTURE-CLASS))|)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T T *) *) 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 SLOT-VALUE-OR-DEFAULT
            MAKE-EFFECTIVE-METHOD-FUNCTION
            GET-EFFECTIVE-METHOD-FUNCTION MAKE-N-N-ACCESSOR-DFUN
            MAKE-CHECKING-DFUN NESTED-WALK-FORM)) 
(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 T) *) 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))|
            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)) 
(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 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)
            |(FAST-METHOD WRAPPER-FETCHER (STANDARD-CLASS))|
            WALKER::WALK-MULTIPLE-VALUE-BIND
            |(FAST-METHOD CLASS-DEFAULT-INITARGS (BUILT-IN-CLASS))|
            WALKER::WALK-SETQ
            |(FAST-METHOD MAKE-INSTANCES-OBSOLETE (STD-CLASS))|
            |(FAST-METHOD SLOTS-FETCHER (STANDARD-CLASS))|
            STANDARD-COMPUTE-EFFECTIVE-METHOD
            WALKER::WALK-SYMBOL-MACROLET PRINT-CACHE
            MAKE-OPTIMIZED-STD-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
            |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (STANDARD-CLASS))|
            MAKE-OPTIMIZED-STD-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
            EMIT-SLOT-READ-FORM WALKER::WALK-TAGBODY
            MAKE-OPTIMIZED-STD-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
            WALKER::RECONS EMIT-BOUNDP-CHECK
            ITERATE::OPTIMIZE-GATHERING-FORM WALKER::WALK-DO
            WALKER::WALK-MULTIPLE-VALUE-SETQ WALKER::WALK-DO*
            |(FAST-METHOD CLASS-CONSTRUCTORS (SLOT-CLASS))|
            WALKER::WALK-PROG
            |(FAST-METHOD CLASS-SLOT-CELLS (STD-CLASS))|
            WALKER::WALK-NAMED-LAMBDA
            |(FAST-METHOD SPECIALIZER-CLASS (CLASS))|
            WALKER::WALK-PROG*
            |(FAST-METHOD SPECIALIZER-CLASS (EQL-SPECIALIZER))|
            EXPAND-DEFGENERIC COMPUTE-EFFECTIVE-METHOD
            NOTE-PV-TABLE-REFERENCE
            |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-ACCESSOR-METHOD))|
            |(FAST-METHOD ACCESSOR-METHOD-CLASS (STANDARD-WRITER-METHOD))|
            |(FAST-METHOD WRAPPER-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
            WALKER::RELIST-INTERNAL INITIALIZE-INTERNAL-SLOT-GFS*
            OPTIMIZE-SLOT-VALUE
            |(FAST-METHOD METHOD-QUALIFIERS (STANDARD-METHOD))|
            SKIP-OPTIMIZE-SLOT-VALUE-BY-CLASS-P MAKE-DFUN-CALL
            |(FAST-METHOD GENERIC-FUNCTION-LAMBDA-LIST (GENERIC-FUNCTION))|
            |(FAST-METHOD SLOTS-FETCHER (FUNCALLABLE-STANDARD-CLASS))|
            WALKER::WALK-TAGBODY-1
            |(FAST-METHOD GF-FAST-METHOD-FUNCTION-P (STANDARD-GENERIC-FUNCTION))|
            OPTIMIZE-SET-SLOT-VALUE SORT-APPLICABLE-METHODS
            WALKER::WALK-LAMBDA SORT-METHODS
            |(FAST-METHOD RAW-INSTANCE-ALLOCATOR (FUNCALLABLE-STANDARD-CLASS))|
            FIRST-FORM-TO-LISP OPTIMIZE-GF-CALL-INTERNAL
            ITERATE::OPTIMIZE-ITERATE-FORM DECLARE-STRUCTURE
            WRAP-METHOD-GROUP-SPECIFIER-BINDINGS
            WALKER::WALK-COMPILER-LET MAKE-TOP-LEVEL-FORM
            OPTIMIZE-SLOT-BOUNDP INVALIDATE-WRAPPER
            |(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))|
            |(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 SPECIALIZER-DIRECT-METHODS (CLASS))|
            |(FAST-METHOD COMPUTE-SLOTS :AROUND (STRUCTURE-CLASS))|
            |(FAST-METHOD CLASS-DIRECT-DEFAULT-INITARGS (SLOT-CLASS))|
            EMIT-GREATER-THAN-1-DLAP
            |(FAST-METHOD SPECIALIZER-DIRECT-GENERIC-FUNCTIONS (CLASS))|
            |(FAST-METHOD CLASS-DEFAULT-INITARGS (SLOT-CLASS))|
            EMIT-1-T-DLAP ITERATE::SIMPLE-EXPAND-GATHERING-FORM
            MAKE-METHOD-INITARGS-FORM-INTERNAL
            ITERATE::RENAME-AND-CAPTURE-VARIABLES
            ITERATE::VARIABLE-SAME-P ENTRY-IN-CACHE-P CONVERT-TABLE
            GET-FUNCTION-GENERATOR MAKE-METHOD-SPEC
            GET-NEW-FUNCTION-GENERATOR TRACE-EMF-CALL-INTERNAL
            TRACE-METHOD-INTERNAL FLUSH-CACHE-TRAP ONE-INDEX-DFUN-INFO
            SET-FUNCTION-NAME-1 ONE-CLASS-DFUN-INFO
            OBSOLETE-INSTANCE-TRAP
            |(FAST-METHOD COMPUTE-CLASS-PRECEDENCE-LIST (SLOT-CLASS))|
            COMPUTE-PRECEDENCE MAP-ALL-ORDERS PRINT-STD-INSTANCE
            CAN-OPTIMIZE-ACCESS |SETF PCL METHOD-FUNCTION-GET|
            SKIP-FAST-SLOT-ACCESS-P |SETF PCL PLIST-VALUE|
            WALKER::WALK-UNEXPECTED-DECLARE
            WALKER::WITH-AUGMENTED-ENVIRONMENT-INTERNAL
            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))|
            VARIABLE-DECLARATION FIX-SLOT-ACCESSORS)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T T T T) T) 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))|
            |(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)) 
(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) 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))|
            |(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)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T T T *) T) GET-METHOD 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)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T T *) T) ENSURE-GENERIC-FUNCTION-USING-CLASS
            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)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T T T T T T T T T *) T)
            BOOTSTRAP-INITIALIZE-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 NIL *) COUNT-ALL-DFUNS EMIT-N-N-READERS
            EMIT-N-N-WRITERS)) 
(PROCLAIM
    '(FTYPE (FUNCTION (*) *) INVALID-METHOD-ERROR
            METHOD-COMBINATION-ERROR UNTRACE-METHOD LIST-LARGE-CACHES
            UPDATE-MAKE-INSTANCE-FUNCTION-TABLE)) 
(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) *) 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
            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)) 
(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
            USE-PACKAGE-PCL ZERO TRUE)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T FIXNUM *) T) GET-CACHE-FROM-CACHE
            COMPUTE-PRIMARY-CACHE-LOCATION-FROM-LOCATION)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T) T) VARIABLE-GLOBALLY-SPECIAL-P
            SYSTEM:%STRUCTURE-NAME SYSTEM:%COMPILED-FUNCTION-NAME
            CLASS-OF ALLOCATE-CACHE-VECTOR SORT-SLOTS
            TWO-CLASS-WRAPPER0 CPD-AFTER GF-INFO-SIMPLE-ACCESSOR-TYPE
            SORT-CALLS FLUSH-CACHE-VECTOR-INTERNAL
            INTERN-EQL-SPECIALIZER EXPAND-SHORT-DEFCOMBIN
            COMPUTE-LINE-SIZE SYMBOL-PKG-NAME ONE-INDEX-CACHE
            MAKE-CALL-METHODS EXTRACT-LAMBDA-LIST
            GF-PRECOMPUTE-DFUN-AND-EMF-P
            CLASS-HAS-A-FORWARD-REFERENCED-SUPERCLASS-P
            EARLY-CLASS-NAME DEFAULT-CONSTANT-CONVERTER
            CANONICAL-SLOT-NAME INITIALIZE-INFO-BOUND-SLOTS
            ONE-INDEX-ACCESSOR-TYPE EARLY-CLASS-SLOTDS
            COMPILE-LAMBDA-UNCOMPILED INITIALIZE-INFO-CACHED-VALID-P
            GF-INFO-STATIC-C-A-M-EMF INITIAL-DISPATCH-P ONE-INDEX-INDEX
            GET-MAKE-INSTANCE-FUNCTIONS GF-LAMBDA-LIST DISPATCH-P
            EXTRACT-PARAMETERS CHECKING-P CHECK-WRAPPER-VALIDITY
            METHOD-FUNCTION-PLIST EXTRACT-SPECIALIZER-NAMES
            ECD-CLASS-NAME CLASS-PREDICATE ARG-INFO-KEYWORDS
            INITIAL-DISPATCH-CACHE UNPARSE-SPECIALIZERS EARLY-GF-NAME
            EXTRACT-REQUIRED-PARAMETERS CHECK-CACHE %SYMBOL-FUNCTION
            ACCESSOR-DFUN-INFO-P MAKE-CLASS-EQ-PREDICATE
            FIND-CYCLE-REASONS FINAL-ACCESSOR-DFUN-TYPE
            FORMAT-CYCLE-REASONS TWO-CLASS-WRAPPER1 COPY-CACHE
            COMPLICATED-INSTANCE-CREATION-METHOD
            INITIALIZE-INFO-CACHED-COMBINED-INITIALIZE-FUNCTION
            MAKE-EQL-PREDICATE DISPATCH-CACHE INITIAL-CACHE
            DEFAULT-STRUCTUREP GF-DFUN-CACHE CHECKING-FUNCTION
            NEXT-WRAPPER-FIELD UPDATE-GF-INFO
            WALKER::ENV-LEXICAL-VARIABLES
            BOOTSTRAP-ACCESSOR-DEFINITIONS CLASS-FROM-TYPE CACHE-OWNER
            CACHING-DFUN-INFO INITIALIZE-INFO-KEY STRUCTURE-SLOTD-TYPE
            DEFAULT-STRUCTURE-INSTANCE-P
            INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION
            BOOTSTRAP-CLASS-PREDICATES EARLY-CLASS-DEFINITION
            DEFAULT-STRUCTURE-TYPE GF-DFUN-INFO
            GET-BUILT-IN-CLASS-SYMBOL DEFAULT-METHOD-ONLY-CACHE
            STRUCTURE-TYPE FGEN-GENERATOR INITIALIZE-INFO-WRAPPER
            DNET-METHODS-P COMPUTE-STD-CPL-PHASE-2
            COMPUTE-APPLICABLE-METHODS-EMF-STD-P
            GET-BUILT-IN-WRAPPER-SYMBOL SETFBOUNDP NET-TEST-CONVERTER
            INITIALIZE-INFO-CACHED-MAKE-INSTANCE-FUNCTION-SYMBOL
            GET-PV-CELL-FOR-CLASS ECD-SOURCE DO-STANDARD-DEFSETF-1
            METHOD-CALL-P FAST-INSTANCE-BOUNDP-P
            ACCESSOR-DFUN-INFO-CACHE WALKER::GET-WALKER-TEMPLATE
            FGEN-SYSTEM GET-SETF-FUNCTION-NAME
            MAKE-INSTANCE-FUNCTION-SYMBOL CONSTANT-VALUE-DFUN-INFO
            INTERN-FUNCTION-NAME METHOD-FUNCTION-FROM-FAST-FUNCTION
            MAKE-FUNCTION-INLINE INTERNED-SYMBOL-P
            INITIALIZE-INFO-CACHED-RI-VALID-P ECD-METACLASS
            UPDATE-ALL-C-A-M-GF-INFO STRUCTURE-SLOT-BOUNDP
            CHECKING-CACHE ONE-INDEX-DFUN-INFO-CACHE
            METHOD-FUNCTION-PV-TABLE LIST-DFUN
            EARLY-SLOT-DEFINITION-NAME UPDATE-PV-TABLE-CACHE-INFO
            USE-CACHING-DFUN-P RESET-CLASS-INITIALIZE-INFO-1
            CONSTANT-VALUE-CACHE ONE-INDEX-DFUN-INFO-ACCESSOR-TYPE
            LIST-LARGE-CACHE GDEFINITION
            INITIALIZE-INFO-CACHED-INITARGS-FORM-LIST CPD-CLASS
            DFUN-INFO-CACHE FUNCTION-RETURNING-NIL EARLY-CLASS-SLOTS
            METHOD-CALL-CALL-METHOD-ARGS METHOD-FUNCTION-METHOD
            SLOT-READER-SYMBOL %FBOUNDP MAKE-PV-TYPE-DECLARATION
            NO-METHODS-CACHE COMPILE-LAMBDA-DEFERRED FREE-CACHE
            KEYWORD-SPEC-NAME STORE-FGEN UPDATE-CLASS-CAN-PRECEDE-P
            INITIALIZE-INFO-CACHED-NEW-KEYS EARLY-CLASS-PRECEDENCE-LIST
            ARG-INFO-APPLYP ITERATE::SEQUENCE-ACCESSOR WRAPPER-FIELD
            N-N-CACHE GF-INFO-C-A-M-EMF-STD-P SLOT-BOUNDP-SYMBOL
            CLASS-PRECEDENCE-DESCRIPTION-P MAKE-CALLS-TYPE-DECLARATION
            GBOUNDP PARSE-SPECIALIZERS CACHING-DFUN-COST
            METHODS-CONTAIN-EQL-SPECIALIZER-P FUNCALLABLE-INSTANCE-P
            %STD-INSTANCE-WRAPPER STRUCTURE-TYPE-INTERNAL-SLOTDS
            GENERIC-CLOBBERS-FUNCTION
            INFORM-TYPE-SYSTEM-ABOUT-STD-CLASS
            ACCESSOR-DFUN-INFO-ACCESSOR-TYPE GMAKUNBOUND
            MAP-SPECIALIZERS UNENCAPSULATED-FDEFINITION
            ONE-INDEX-DFUN-INFO-P SHOW-DFUN-COSTS N-N-ACCESSOR-TYPE
            MAKE-DEFAULT-METHOD-GROUP-DESCRIPTION RESET-INITIALIZE-INFO
            INITIALIZE-INFO-CACHED-DEFAULT-INITARGS-FUNCTION
            MAKE-TYPE-PREDICATE METHOD-FUNCTION-NEEDS-NEXT-METHODS-P
            %STD-INSTANCE-SLOTS GF-INFO-FAST-MF-P
            FAST-METHOD-CALL-PV-CELL DFUN-INFO-P ECD-CANONICAL-SLOTS
            MAKE-OPTIMIZED-STRUCTURE-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
            SLOT-VECTOR-SYMBOL UPDATE-GF-SIMPLE-ACCESSOR-TYPE CCLOSUREP
            RESET-CLASS-INITIALIZE-INFO WRAPPER-FOR-STRUCTURE
            FTYPE-DECLARATION-FROM-LAMBDA-LIST EVAL-FORM
            EARLY-SLOT-DEFINITION-LOCATION CPD-SUPERS NO-METHODS-P
            PV-TABLEP UNDEFMETHOD-1 ONE-CLASS-CACHE
            WALKER::ENV-WALK-FUNCTION EARLY-METHOD-QUALIFIERS
            WALKER::ENV-LOCK MAKE-PERMUTATION-VECTOR FGEN-GENSYMS
            MAP-ALL-GENERIC-FUNCTIONS GET-CACHE-VECTOR
            FAST-METHOD-CALL-NEXT-METHOD-CALL
            WALKER::GET-IMPLEMENTATION-DEPENDENT-WALKER-TEMPLATE
            ONE-INDEX-DFUN-INFO-INDEX UPDATE-GFS-OF-CLASS
            DEFAULT-TEST-CONVERTER TWO-CLASS-P STD-INSTANCE-P
            EARLY-COLLECT-CPL ONE-CLASS-ACCESSOR-TYPE
            STRUCTURE-TYPE-INCLUDED-TYPE-NAME
            PROCLAIM-INCOMPATIBLE-SUPERCLASSES DEFAULT-CONSTANTP
            STRUCTURE-OBJECT-P COUNT-DFUN FAST-METHOD-CALL-P
            CONSTANT-SYMBOL-P ONE-CLASS-INDEX
            INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-T-FUNCTION
            ECD-OTHER-INITARGS CACHING-P EXPAND-LONG-DEFCOMBIN
            EARLY-COLLECT-SLOTS COMPUTE-MCASE-PARAMETERS
            ARG-INFO-LAMBDA-LIST BUILT-IN-WRAPPER-OF MAKE-INITIAL-DFUN
            WRAPPER-OF STRUCTURE-TYPE-SLOT-DESCRIPTION-LIST
            EXPAND-MAKE-INSTANCE-FORM FREE-CACHE-VECTOR
            MAKE-STRUCTURE-SLOT-BOUNDP-FUNCTION MAKE-INITFUNCTION
            TWO-CLASS-CACHE DO-STANDARD-DEFSETFS-FOR-DEFCLASS
            SLOT-INITARGS-FROM-STRUCTURE-SLOTD GFS-OF-TYPE INITIAL-P
            ARG-INFO-P COMPUTE-CLASS-SLOTS ARG-INFO-PRECEDENCE
            BUILT-IN-OR-STRUCTURE-WRAPPER1 DEFAULT-METHOD-ONLY-P
            EARLY-METHOD-STANDARD-ACCESSOR-P CACHE-P
            MAKE-CONSTANT-FUNCTION STRUCTURE-SLOTD-READER-FUNCTION
            N-N-P
            MAKE-OPTIMIZED-STRUCTURE-SETF-SLOT-VALUE-USING-CLASS-METHOD-FUNCTION
            TWO-CLASS-ACCESSOR-TYPE STANDARD-SVUC-METHOD TYPE-CLASS
            LEGAL-CLASS-NAME-P EARLY-CLASS-NAME-OF
            EARLY-METHOD-LAMBDA-LIST MAKE-PV-TABLE-TYPE-DECLARATION
            ARG-INFO-METATYPES TWO-CLASS-INDEX FGEN-TEST
            FUNCTION-PRETTY-ARGLIST STRUCTURE-SLOTD-NAME
            FUNCTION-RETURNING-T METHOD-LL->GENERIC-FUNCTION-LL
            EARLY-CLASS-DIRECT-SUBCLASSES ITERATE::VARIABLES-FROM-LET
            GET-MAKE-INSTANCE-FUNCTION-SYMBOL
            INITIALIZE-INFO-CACHED-SHARED-INITIALIZE-NIL-FUNCTION
            ONE-CLASS-WRAPPER0 STRUCTURE-TYPE-P FORCE-CACHE-FLUSHES
            ARG-INFO-VALID-P GET-MAKE-INSTANCE-FUNCTION
            FGEN-GENERATOR-LAMBDA EARLY-ACCESSOR-METHOD-SLOT-NAME
            STRUCTURE-SLOTD-ACCESSOR-SYMBOL FAST-METHOD-CALL-ARG-INFO
            WALKER::ENV-WALK-FORM %CCLOSURE-ENV CONSTANT-VALUE-P
            SLOT-WRITER-SYMBOL DFUN-ARG-SYMBOL CACHING-CACHE
            ARG-INFO-NUMBER-OPTIONAL EARLY-COLLECT-DEFAULT-INITARGS
            SFUN-P
            MAKE-OPTIMIZED-STRUCTURE-SLOT-BOUNDP-USING-CLASS-METHOD-FUNCTION
            STRUCTURE-SVUC-METHOD EARLY-METHOD-CLASS
            USE-DEFAULT-METHOD-ONLY-DFUN-P LOOKUP-FGEN
            ARG-INFO-KEY/REST-P ARG-INFO-NKEYS
            DEFAULT-SECONDARY-DISPATCH-FUNCTION
            INITIALIZE-INFO-CACHED-CONSTANTS INITIALIZE-INFO-P
            EARLY-GF-P
            INITIALIZE-INFO-CACHED-COMBINED-INITARGS-FORM-LIST
            WALKER::ENV-DECLARATIONS ONE-INDEX-P ECD-SUPERCLASS-NAMES
            STRUCTURE-SLOTD-WRITER-FUNCTION ONE-CLASS-P
            UPDATE-C-A-M-GF-INFO)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T *) *) WALK-FORM MACROEXPAND-ALL
            ENSURE-GENERIC-FUNCTION 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 DISPATCH-DFUN-COST MAKE-INSTANCE-1
            ENSURE-CLASS)) 
(PROCLAIM '(FTYPE (FUNCTION (T T *) (VALUES T T)) SYMBOL-APPEND)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T *) T) CAPITALIZE-WORDS
            INITIALIZE-INTERNAL-SLOT-GFS 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
            WALKER::WALKER-ENVIRONMENT-BIND-1
            ALLOCATE-STANDARD-INSTANCE ITERATE::FUNCTION-LAMBDA-P
            ITERATE::MAYBE-WARN MAKE-WRAPPER FIND-CLASS)) 
(PROCLAIM
    '(FTYPE (FUNCTION (T T) *) SLOT-BOUNDP SLOT-VALUE SLOT-MAKUNBOUND
            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 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 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) VARIABLE-LEXICAL-P
            WALKER::NOTE-DECLARATION VARIABLE-SPECIAL-P
            MAKE-DFUN-LAMBDA-LIST WALKER::NOTE-LEXICAL-BINDING
            MAKE-DLAP-LAMBDA-LIST ADD-DIRECT-SUBCLASSES COMPUTE-PV
            MAKE-DFUN-ARG-LIST COMPUTE-CALLS
            SYSTEM:%SET-COMPILED-FUNCTION-NAME
            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 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 ADD-METHOD ITERATE::MV-SETQ
            MAKE-UNORDERED-METHODS-EMF CLASS-MIGHT-PRECEDE-P
            ITERATE::EXTRACT-SPECIAL-BINDINGS
            WALKER::VARIABLE-SYMBOL-MACRO-P RAISE-METATYPE
            PROCLAIM-DEFMETHOD 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 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
            FUNCALLABLE-STANDARD-INSTANCE-ACCESS
            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 SLOT-EXISTS-P REMTAIL
            DESTRUCTURE-INTERNAL ACCESSOR-MISS-FUNCTION
            UPDATE-INITIALIZE-INFO-INTERNAL N-N-DFUN-INFO MAKE-CAXR
            MAKE-CDXR STANDARD-INSTANCE-ACCESS CHECKING-DFUN-INFO
            MAKE-PV-TABLE-INTERNAL FIND-SLOT-DEFINITION
             WALKER::WALK-REPEAT-EVAL REMOVE-METHOD
            SET-FUNCALLABLE-INSTANCE-FUNCTION)) 
(PROCLAIM '(FTYPE (FUNCTION NIL FIXNUM) GET-WRAPPER-CACHE-NUMBER)) 
(IN-PACKAGE "PCL")

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