anchor.diff:                   #'compute-effective-method-function)
                gf applicable-methods)))
       (setf (gethash classes (classes-to-emf-table gf)) emfun)
  +    (funcall emfun args)))
  +
  +(defun slow-single-dispatch-method-lookup (gf args class)
  +  (let* ((classes (mapcar #'class-of
  +                          (required-portion gf args)))
  +         (applicable-methods
  +          (compute-applicable-methods-using-classes gf classes))
  +         (emfun (std-compute-effective-method-function gf applicable-methods)))
  +    (setf (gethash class (classes-to-emf-table gf)) emfun)
       (funcall emfun args)))
   
   ;;; compute-applicable-methods-using-classes
  
positive.code:   (slot-value gf 'method-class))
  (defun (setf generic-function-method-class) (new-value gf)
    (setf (slot-value gf 'method-class) new-value))
  
  ;;; Internal accessor for effective method function table
  
  
negative.code: ;;; function table.
  
  (defun finalize-generic-function (gf)
    ;; Examine all methods and compute the relevant argument bit-vector.
    (let* ((required-args (gf-required-arglist gf))
           (relevant-args (make-array (length required-args)
                                      ;:element-type 'bit
                                      :initial-element 0))
           (class-t (find-class 't)))
      (dolist (m (generic-function-methods gf))
        (do ((i 0 (1+ i))
             (spec (method-specializers m) (rest spec)))
            ((null spec))
          (unless (eql (first spec) class-t)
            (setf (aref relevant-args i) 1))))
      (setf (generic-function-relevant-arguments gf) relevant-args))
    (setf (generic-function-discriminating-function gf)
          (funcall (if (eq (class-of gf) the-class-standard-gf)
                       #'std-compute-discriminating-function
  