anchor.diff:  
   ;;; CLASSES-OF-METHOD is a list of specializers (which much be classes)
   ;;; of a single method of the generic function.
  -(defun add-to-call-history (generic-function classes-of-method)
  +(defun add-to-call-history (generic-function classes-of-method profile)
     (let* ((sets (loop for class in classes-of-method
  -		     collect (if (eq class *t*)
  +		     for flag in profile
  +		     collect (if (null flag)
   				 (list class)
   				 (all-descendents class))))
  -	 (all-combinations (cartesian-product sets))
  -	 (mc (generic-function-method-combination generic-function)))
  +	 (all-combinations (cartesian-product sets)))
       (loop for combination in all-combinations
   	  for methods = (compute-applicable-methods-using-classes
   			 generic-function combination)
  -	  for em = (compute-effective-method
  -		    generic-function
  -		    mc
  -		    (final-methods methods combination))
  -	  for no-t = (remove *t* combination)
  -	  for numbers = (mapcar #'unique-number no-t)
  +	  for relevant-classes = (loop for class in combination
  +				       for flag in profile
  +				       when flag collect class)
  +	  for numbers = (mapcar #'unique-number relevant-classes)
   	  do (unless (member numbers (call-history generic-function)
   			     :key #'class-number-cache :test #'equal)
  -	       (push (make-call-cache numbers methods em)
  -		     (call-history generic-function))))))
  +	       (add-call-cache generic-function
  +			       numbers
  +			       combination
  +			       methods)))))
   
   (defun load-call-history (generic-function)
  -  (loop for method in (generic-function-methods generic-function)
  +  (loop with profile = (specializer-profile generic-function)
  +	for method in (generic-function-methods generic-function)
   	for specializers = (method-specializers method)
  -	do (add-to-call-history generic-function specializers)))
  +	do (add-to-call-history generic-function specializers profile)))
   
   (defun satiate-generic-function (generic-function)
     (load-call-history generic-function)
  -  (let ((df (compute-discriminating-function generic-function)))
  -    (set-funcallable-instance-function generic-function df)))
  +  (compute-and-install-discriminating-function generic-function))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  
positive.code:   (loop for method in methods
  	collect (maybe-replace-method method classes)))
  
  ;;; This function can not itself be the discriminating function of a
  ;;; generic function, because it also takes the generic function
  ;;; itself as an argument.  However it can be called by the
  
negative.code:       (multiple-value-bind (applicable-methods ok)
  	  (compute-applicable-methods-using-classes generic-function classes)
  	(when ok
  	  (let ((effective-method (add-call-cache generic-function
  						  class-numbers
  						  classes
  						  applicable-methods)))
  	    (return-from default-discriminating-function
  	      (apply effective-method arguments))))
  	;; Come here if we can't compute the applicable methods using
  