anchor.diff:              (setf (class-dependents class) (remove gf (class-dependents class))))
             (classes-to-emf-table gf))
            (clear-single-dispatch-emf-table (classes-to-emf-table gf)))
  -        (t (loop
  -              for classes being the hash-keys in (classes-to-emf-table gf)
  -              do (loop
  -                    for class in classes
  -                    do (setf (class-dependents class) (remove gf (class-dependents class)))))
  -           (clrhash (classes-to-emf-table gf)))))
  +        ((classes-to-emf-table gf)
  +         (loop
  +            for classes being the hash-keys in (classes-to-emf-table gf)
  +            do (loop
  +                  for class in classes
  +                  do (setf (class-dependents class) (remove gf (class-dependents class)))))
  +         (clrhash (classes-to-emf-table gf)))))
   
   (defun required-portion (gf args)
     (let ((number-required (length (gf-required-arglist 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."
  