anchor.diff:  (defun class-name (class)
     (std-slot-value class 'name))
   (defun (setf class-name) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'name) new-value))
   
   (defun class-direct-superclasses (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (slot-value class 'direct-superclasses))
   (defun (setf class-direct-superclasses) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'direct-superclasses) new-value))
   
   (defun class-direct-slots (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (slot-value class 'direct-slots))
   (defun (setf class-direct-slots) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'direct-slots) new-value))
   
   (defun class-precedence-list (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (let ((class-of-class (class-of class)))
       (cond ((std-class-p class-of-class)
              (svref (std-instance-slots class) *standard-class-precedence-list-position*))
             (t
              (slot-value class 'class-precedence-list)))))
   (defun (setf class-precedence-list) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'class-precedence-list) new-value))
   
   (defun class-slots (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (let ((class-of-class (class-of class)))
       (cond ((clos-class-p class-of-class)
              (svref (std-instance-slots class) *standard-class-effective-slots-position*))
             (t (slot-value class 'effective-slots)))))
   (defun (setf class-slots) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'effective-slots) new-value))
   
   (defun class-slot-storage-layout (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (let ((class-of-class (class-of class)))
       (cond ((clos-class-p class-of-class)
              (svref (std-instance-slots class) *standard-class-slot-storage-layout-position*))
             (t (slot-value class 'slot-storage-layout)))))
   (defun (setf class-slot-storage-layout) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'slot-storage-layout) new-value))
   
   (defun class-direct-subclasses (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (slot-value class 'direct-subclasses))
   (defun (setf class-direct-subclasses) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'direct-subclasses) new-value))
   
   (defun class-direct-methods (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (slot-value class 'direct-methods))
   (defun (setf class-direct-methods) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'direct-methods) new-value))
   
   (defun class-direct-default-initargs (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (let ((class-of-class (class-of class)))
       (cond ((clos-class-p class-of-class)
              (svref (std-instance-slots class) *standard-class-direct-default-initargs-position*))
             (t (slot-value class 'direct-default-initargs)))))
   (defun (setf class-direct-default-initargs) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'direct-default-initargs) new-value))
   
   (defun class-dependents (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (std-slot-value class 'dependents))
   (defun (setf class-dependents) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'dependents) new-value))
   
   (defun class-hash (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (let ((class-of-class (class-of class)))
       (cond ((clos-class-p class-of-class)
              (svref (std-instance-slots class) *standard-class-hash-position*))
             (t (std-slot-value class 'hash)))))
   (defun (setf class-hash) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'hash) new-value))
   
   (defun class-finalized-p (class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (let ((class-of-class (class-of class)))
       (cond ((clos-class-p class-of-class)
              (svref (std-instance-slots class) *standard-class-finalized-p-position*))
             (t (std-slot-value class 'finalized-p)))))
   (defun (setf class-finalized-p) (new-value class)
  +  (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
     (setf (slot-value class 'finalized-p) new-value))
   
   ;;; Ensure class
  
positive.code: (sys.int::defglobal *the-class-standard-gf*) ;standard-generic-function's class metaobject
  
  (defun generic-function-name (gf)
    (slot-value gf 'name))
  (defun (setf generic-function-name) (new-value gf)
    (setf (slot-value gf 'name) new-value))
  
  (defun generic-function-lambda-list (gf)
    (slot-value gf 'lambda-list))
  (defun (setf generic-function-lambda-list) (new-value gf)
    (setf (slot-value gf 'lambda-list) new-value))
  
  (defun generic-function-methods (gf)
    (slot-value gf 'methods))
  (defun (setf generic-function-methods) (new-value gf)
    (setf (slot-value gf 'methods) new-value))
  
  (defun generic-function-discriminating-function (gf)
    (slot-value gf 'discriminating-function))
  (defun (setf generic-function-discriminating-function) (new-value gf)
    (setf (slot-value gf 'discriminating-function) new-value))
  
  (defun generic-function-method-class (gf)
    (slot-value gf 'method-class))
  (defun (setf generic-function-method-class) (new-value gf)
    (setf (slot-value gf 'method-class) new-value))
  
  (defun generic-function-relevant-arguments (gf)
    (slot-value gf 'relevant-arguments))
  (defun (setf generic-function-relevant-arguments) (new-value gf)
    (setf (slot-value gf 'relevant-arguments) new-value))
  
  (defun generic-function-has-unusual-specializers (gf)
    (slot-value gf 'weird-specializers-p))
  (defun (setf generic-function-has-unusual-specializers) (new-value gf)
    (setf (slot-value gf 'weird-specializers-p) new-value))
  
  (defun generic-function-method-combination (gf)
    (slot-value gf 'method-combination))
  (defun (setf generic-function-method-combination) (new-value gf)
    (setf (slot-value gf 'method-combination) new-value))
  
  (defun generic-function-argument-precedence-order (gf)
    (slot-value gf 'argument-precedence-order))
  (defun (setf generic-function-argument-precedence-order) (new-value gf)
    (setf (slot-value gf 'argument-precedence-order) new-value))
  
  (defun generic-function-declarations (gf)
    (slot-value gf 'declarations))
  (defun (setf generic-function-declarations) (new-value gf)
    (setf (slot-value gf 'declarations) new-value))
  
  ;;; Internal accessor for effective method function table
  
  (defun classes-to-emf-table (gf)
    (slot-value gf 'classes-to-emf-table))
  (defun (setf classes-to-emf-table) (new-value gf)
    (setf (slot-value gf 'classes-to-emf-table) new-value))
  
  (defun argument-reordering-table (gf)
    (slot-value gf 'argument-reordering-table))
  (defun (setf argument-reordering-table) (value gf)
    (setf (slot-value gf 'argument-reordering-table) value))
  
  ;;;
  
negative.code:                                                    collect (eql-specializer-object spec)))))))
  
  (defun slow-single-dispatch-method-lookup* (gf argument-offset args state)
    (declare (notinline slot-value (setf slot-value))) ; Bootstrap hack
    (let ((emf-table (classes-to-emf-table gf)))
      (ecase state
        (:reader
  