anchor.diff:  
   ;;; compute-discriminating-function
   
  -(defun compute-reader-discriminator (gf emf-table argument-offset)
  +(defun compute-reader-discriminator (gf emf-table argument-offset slot-definition)
     (lambda (object)
       (let* ((class (class-of object))
              (location (single-dispatch-emf-entry emf-table class)))
         (if location
  -          (fast-slot-read object location)
  +          (fast-slot-read object location slot-definition)
             (slow-single-dispatch-method-lookup* gf argument-offset (list object) :reader)))))
   
  -(defun compute-writer-discriminator (gf emf-table argument-offset)
  +(defun compute-writer-discriminator (gf emf-table argument-offset slot-definition)
     (lambda (new-value object)
       (let* ((class (class-of object))
              (location (single-dispatch-emf-entry emf-table class)))
         (if location
  -          (fast-slot-write new-value object location)
  +          (fast-slot-write new-value object location slot-definition)
             (slow-single-dispatch-method-lookup* gf argument-offset (list new-value object) :writer)))))
   
   (defun compute-1-effective-discriminator (gf emf-table argument-offset)
  
positive.code:                                 instance
                                  (if (consp location)
                                      (car location)
                                      (safe-slot-definition-name (elt (safe-class-slots (class-of instance)) location)))))
            val))))
  
  (defun fast-slot-write (new-value instance location)
    (multiple-value-bind (slots layout)
        ;; This is required in case the instance is obsolete.
        (fetch-up-to-date-instance-slots-and-layout instance)
  
negative.code:                      (typep (first applicable-methods) 'standard-reader-method)
                       (std-class-p (class-of class)))
                  (let* ((instance (first args))
                         (slot-def (accessor-method-slot-definition (first applicable-methods)))
                         (slot-name (slot-definition-name slot-def))
                         (effective-slot (find-effective-slot instance slot-name)))
                    (cond (effective-slot
                           (let ((location (safe-slot-definition-location effective-slot)))
                             (setf (single-dispatch-emf-entry emf-table class) location)
                             (fast-slot-read (first args) location slot-def)))
                          (t
                           ;; Slot not present, fall back on SLOT-VALUE.
                           (slot-value instance slot-name)))))
  