anchor.diff:  ;;; 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
  
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: ;;; compute-discriminating-function
  
  (defun std-compute-discriminating-function (gf)
    (multiple-value-bind (single-dispatch-p argument-offset)
        (generic-function-single-dispatch-p gf)
      (if single-dispatch-p
          #'(lambda (&rest args)
              (let* ((class (class-of (nth argument-offset args)))
                     (emfun (gethash class (classes-to-emf-table gf) nil)))
                (if emfun
                    (funcall emfun args)
                    (slow-single-dispatch-method-lookup gf args class))))
          #'(lambda (&rest args)
              (let* ((classes (mapcar #'class-of
                                      (required-portion gf args)))
                     (emfun (gethash classes (classes-to-emf-table gf) nil)))
                (if emfun
                    (funcall emfun args)
                    (slow-method-lookup gf args classes)))))))
  
  (defun slow-method-lookup (gf args classes)
    (let* ((applicable-methods
            (compute-applicable-methods-using-classes gf classes))
           (emfun
             (funcall
               (if (eq (class-of gf) the-class-standard-gf)
  