anchor.diff:  
   ;;;;
   
  +;;; Modified to make this obey the spec better by using a hash-table
  +;;; for detecting previous nodes only when the duplicate-test argument
  +;;; permits it.  [2005/08/10:rpg]
   (defmethod generate-graph-nodes ((graph-output-record standard-graph-output-record)
                                    stream root-objects
                                    object-printer inferior-producer
                                    &key duplicate-key duplicate-test)
  -  (declare (ignore duplicate-test))
  -  (with-slots (cutoff-depth merge-duplicates hash-table) graph-output-record
  -    (labels
  -        ((traverse-objects (node objects depth)
  -           (unless (and cutoff-depth (>= depth cutoff-depth))
  -             (remove nil
  -                     (map 'list
  -                          (lambda (child)
  -                            (let* ((key (funcall duplicate-key child))
  -                                   (child-node (and merge-duplicates
  -                                                    (gethash key hash-table))))
  -                              (cond (child-node
  -                                     (when node
  -                                       (push node (graph-node-parents child-node)))
  -                                     child-node)
  -                                    (t
  -                                     (let ((child-node
  -                                            (with-output-to-output-record
  -                                                (stream 'standard-graph-node-output-record new-node
  -                                                        :object child)
  -                                              (funcall object-printer child stream))))
  -                                       (when merge-duplicates
  -                                         (setf (gethash key hash-table) child-node))
  -                                       (when node
  -                                         (push node (graph-node-parents child-node)))
  -                                       (setf (graph-node-children child-node)
  -                                             (traverse-objects child-node
  -                                                              (funcall inferior-producer child)
  -                                                              (+ depth 1)))
  -                                       child-node)))))
  -                          objects)))))
  -      ;;
  -      (setf (graph-root-nodes graph-output-record)
  -            (traverse-objects nil root-objects 0))
  -      (values))))
  +  (with-slots (cutoff-depth merge-duplicates) graph-output-record
  +    (let* ((hash-table (when (and merge-duplicates (member duplicate-test (list #'eq #'eql #'equal #'equalp)))
  +			 (make-hash-table :test duplicate-test)))
  +	   node-list 
  +	   (hashed hash-table))
  +      (labels
  +	  ((previous-node (obj)
  +	     ;; is there a previous node for obj?  if so, return it.
  +	     (when merge-duplicates
  +	       (if hashed
  +		   (locally (declare (type hash-table hash-table))
  +		     (gethash obj hash-table))
  +		 (cdr (assoc obj node-list :test duplicate-test)))))
  +	   ((setf previous-node) (val obj)
  +	     (if hashed
  +		 (locally (declare (type hash-table hash-table))
  +		   (setf (gethash obj hash-table) val))
  +		 (setf node-list (push (cons obj val) node-list))))
  +	   (traverse-objects (node objects depth)
  +	     (unless (and cutoff-depth (>= depth cutoff-depth))
  +	       (remove nil
  +		       (map 'list
  +			 (lambda (child)
  +			   (let* ((key (funcall duplicate-key child))
  +				  (child-node (previous-node key)))
  +			     (cond (child-node
  +				    (when node
  +				      (push node (graph-node-parents child-node)))
  +				    child-node)
  +				   (t
  +				    (let ((child-node
  +					   (with-output-to-output-record
  +					       (stream 'standard-graph-node-output-record new-node
  +						       :object child)
  +					     (funcall object-printer child stream))))
  +				      (when merge-duplicates
  +					(setf (previous-node key) child-node)
  +					;; (setf (gethash key hash-table) child-node)
  +					)
  +				      (when node
  +					(push node (graph-node-parents child-node)))
  +				      (setf (graph-node-children child-node)
  +					(traverse-objects child-node
  +							  (funcall inferior-producer child)
  +							  (+ depth 1)))
  +				      child-node)))))
  +			 objects)))))
  +	;;
  +	(setf (graph-root-nodes graph-output-record)
  +	  (traverse-objects nil root-objects 0))
  +	(values)))))
   
   (defun traverse-graph-nodes (graph continuation)
     ;; continuation: node x children x cont -> some value
  
positive.code:                    (if (eq orientation :vertical)
                         (bounding-rectangle-width node)
                         (bounding-rectangle-height node)))
                   (walk (node depth)
                     (unless (graph-node-minor-size node)
                       (when (>= depth (length generation-sizes))
  
negative.code:                     #'cont
                      (find-graph-type graph-type)
  		    nil
  		    ;; moved to local variable... [2005/07/25:rpg]
                      ;; :hash-table (make-hash-table :test duplicate-test)
  		    graph-options 
  		    ))))
        (setf (output-record-position graph-output-record)
              (values cursor-old-x cursor-old-y))
        (with-output-recording-options (stream :draw t :record nil)
  