anchor.diff:  ;;; but in no particular order.  We must be careful here, in that we
   ;;; might have to handle an incorrect inheritance graph, that might
   ;;; contain circular dependencies.
  -;; (defun find-all-superclasses (class)
  -;;   (let ((result '()))
  -;;     (labels ((find-all-supers (class)
  -;; 	       (unless (member class all-supers :test #'eq)
  -;; 		 (push class all-supers)
  -;; 		 (loop for super in (class-direct-superclasses class)
  -;; 		       do (find-all-supers super)))))
  -;;       (find-all-supers class))
  -;;     result))
  +(defun find-all-superclasses (class)
  +  (let ((result '()))
  +    (labels ((find-all-supers (class)
  +	       (unless (member class result :test #'eq)
  +		 (push class result)
  +		 (loop for super in (class-direct-superclasses class)
  +		       do (find-all-supers super)))))
  +      (find-all-supers class))
  +    result))
   
   ;;; For a given class, compute a precedence relation.  
   ;;; This relation is represented as a list of cons cells, 
  
positive.code: ;;; looks the same, but with a different name and then we transfer the
  ;;; slots from the fake class to the bare standard-instance.
  
  (defclass fake (slot-definition)
    #.*direct-slots-standard-class*)
  
  (let ((to-patch (find-class 'standard-class))
  
negative.code: ;;; looks the same, but with a different name and then we transfer the
  ;;; class and slots from the fake class to the bare standard-instance.
  
  (defclass fake (standard-slot-definition direct-slot-definition)
    #.*direct-slots-standard-direct-slot-definition*)
  
  (let ((to-patch (find-class 'standard-direct-slot-definition))
  