anchor.diff:                                           (make-single-dispatch-emf-table))
                                           ((generic-function-unspecialized-dispatch-p gf)
                                            nil)
  -                                        (t (make-hash-table :test #'equal))))
  +                                        (t
  +                                         (make-emf-cache gf))))
     (set-funcallable-instance-function
      gf
      (funcall (if (standard-generic-function-instance-p gf)
  
positive.code:               (compute-n-effective-discriminator gf (classes-to-emf-table gf) (length (gf-required-arglist gf))))
               (apply gf args))))))
  
  (defun slow-method-lookup (gf args classes)
    (multiple-value-bind (applicable-methods validp)
        (if (eql (class-of gf) *the-class-standard-gf*)
            (std-compute-applicable-methods-using-classes gf classes)
            (compute-applicable-methods-using-classes gf classes))
      (unless validp
        (setf applicable-methods (if (eql (class-of gf) *the-class-standard-gf*)
                                     (std-compute-applicable-methods gf args)
                                     (compute-applicable-methods gf args))))
      (let ((emfun (cond (applicable-methods
                          (funcall
                           (if (eq (class-of gf) *the-class-standard-gf*)
                               #'std-compute-effective-method-function
                               #'compute-effective-method-function)
                           gf applicable-methods))
                         (t
                          (lambda (&rest args)
                            (apply #'no-applicable-method gf args))))))
        ;; Cache is only valid for non-eql methods.
        (when validp
          (setf (gethash classes (classes-to-emf-table gf)) emfun))
        (apply emfun args))))
  
  (defun slow-single-dispatch-method-lookup (gf args class)
    (let* ((classes (mapcar #'class-of (required-portion gf args))))
  
negative.code:       (error 'sys.int::simple-program-error
               :format-control "Too few arguments to generic function ~S."
               :format-arguments (list gf)))
      (let* ((emfun (emf-cache-lookup emf-table args)))
        (if emfun
            (apply emfun args)
            (slow-method-lookup gf args)))))
  
  (defun compute-1-effective-eql-table (gf argument-offset)
    (loop
  