anchor.diff:                                    ;    -discriminating-function
          (classes-to-emf-table      ; :accessor classes-to-emf-table
             :initform (make-hash-table :test #'equal))
  -       (relevant-arguments))      ; :accessor generic-function-relevant-arguments
  +       (relevant-arguments)       ; :accessor generic-function-relevant-arguments
  +       (weird-specializers-p)     ; :accessor generic-function-has-unusual-specializers
  +       )
         (:metaclass funcallable-standard-class)))
   
   (defvar the-class-standard-gf) ;standard-generic-function's class metaobject
  
positive.code:   (setf (method-generic-function method) gf)
    (push method (generic-function-methods gf))
    (dolist (specializer (method-specializers method))
      (pushnew method (class-direct-methods specializer)))
    (finalize-generic-function gf)
    method)
  
  
negative.code:                (apply gf args))))))
  
  (defun slow-method-lookup (gf args classes)
    (multiple-value-bind (applicable-methods validp)
        (compute-applicable-methods-using-classes gf classes)
      (unless validp
        (setf applicable-methods (compute-applicable-methods gf args)))
      (let ((emfun (funcall
                    (if (eq (class-of gf) the-class-standard-gf)
                        #'std-compute-effective-method-function
                        #'compute-effective-method-function)
                    gf applicable-methods)))
        ;; Cache is only valid for non-eql methods.
        (when validp
          (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
  