anchor.diff:          (generic-function-single-dispatch-p gf)
         (cond (single-dispatch-p
                (slow-single-dispatch-method-lookup* gf argument-offset args :never-called))
  +            ((generic-function-unspecialized-dispatch-p gf)
  +             (slow-unspecialized-dispatch-method-lookup gf args))
               (t (setf (generic-function-discriminating-function gf)
                        (compute-n-effective-discriminator gf (classes-to-emf-table gf) (length (gf-required-arglist gf))))
                  (set-funcallable-instance-function gf (generic-function-discriminating-function gf))
  
positive.code:           (setf (bit relevant-args i) 1))))
      (setf (generic-function-relevant-arguments gf) relevant-args))
    (reset-gf-emf-table gf)
    (setf (classes-to-emf-table gf) (if (generic-function-single-dispatch-p gf)
                                        (make-single-dispatch-emf-table)
                                        (make-hash-table :test #'equal)))
    (setf (generic-function-discriminating-function gf)
          (funcall (if (eq (class-of gf) *the-class-standard-gf*)
                       #'std-compute-discriminating-function
  
negative.code:            (setf (fdefinition function-name) gf)
             gf))))
  
  (defun generic-function-unspecialized-dispatch-p (gf)
    "Returns true when the generic function has no methods with non-t specialized arguments."
    (and (eq (class-of gf) *the-class-standard-gf*)
         (every (lambda (method)
                  (every (lambda (spec)
                           (eql spec *the-class-t*))
                         (method-specializers method)))
                (generic-function-methods gf))))
  
  (defun generic-function-single-dispatch-p (gf)
    "Returns true when the generic function only one non-t specialized argument and
  has only has class specializer."
  