anchor.diff:                    (sublis-eql-identity alist tree)
                     (sublis-test-identity alist tree test)))
             (if test-not
  -              (if (or (eq test-not #'eq) (eq test-not 'eq))
  -                  (sublis-not-eq-identity alist tree)
  -                  (if (or (eq test-not #'eql) (eq test-not 'eql))
  -                      (sublis-not-eql-identity alist tree)
  -                      (sublis-test-not-identity alist tree test-not)))
  +	      (sublis-test-not-identity alist tree test-not)
                 (sublis-eql-identity alist tree)))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
positive.code:       (let ((new-tree (traverse tree)))
  	(if substitution-p new-tree tree)))))
  
  ;;; Special case when test-not is eq and key is identity
  
  (defun sublis-not-eq-identity (alist tree)
    (let ((substitution-p nil))
      (labels ((traverse (tree)
  	       (let ((entry (assoc-not-eq-identity tree alist)))
  		 (cond ((not (null entry))
  			(setf substitution-p t)
  			(cdr entry))
  		       ((atom tree) tree)
  		       (t (cons (traverse (car tree))
  				(traverse (cdr tree))))))))
        (let ((new-tree (traverse tree)))
  	(if substitution-p new-tree tree)))))
    
  ;;; Special case when test-not is eql and key is identity
  
  (defun sublis-not-eql-identity (alist tree)
    (let ((substitution-p nil))
      (labels ((traverse (tree)
  	       (let ((entry (assoc-not-eql-identity tree alist)))
  		 (cond ((not (null entry))
  			(setf substitution-p t)
  			(cdr entry))
  		       ((atom tree) tree)
  		       (t (cons (traverse (car tree))
  				(traverse (cdr tree))))))))
        (let ((new-tree (traverse tree)))
  	(if substitution-p new-tree tree)))))
    
  ;;; Special case when test-not is eq and key is given.
  
  (defun sublis-not-eq-key (alist tree key)
    (let ((substitution-p nil))
      (labels ((traverse (tree)
  	       (let ((entry (assoc-not-eq-identity (funcall key tree)
  						   alist)))
  		 (cond ((not (null entry))
  			(setf substitution-p t)
  			(cdr entry))
  		       ((atom tree) tree)
  		       (t (cons (traverse (car tree))
  				(traverse (cdr tree))))))))
        (let ((new-tree (traverse tree)))
  	(if substitution-p new-tree tree)))))
  
  ;;; Special case when test-not is eql and key is given.
  
  (defun sublis-not-eql-key (alist tree key)
    (let ((substitution-p nil))
      (labels ((traverse (tree)
  	       (let ((entry (assoc-not-eql-identity (funcall key tree)
  						    alist)))
  		 (cond ((not (null entry))
  			(setf substitution-p t)
  			(cdr entry))
  		       ((atom tree) tree)
  		       (t (cons (traverse (car tree))
  				(traverse (cdr tree))))))))
        (let ((new-tree (traverse tree)))
  	(if substitution-p new-tree tree)))))
  
  ;;; Special case when test-not is given and key is identity.
  
  (defun sublis-test-not-identity (alist tree test)
  
negative.code:                   (sublis-eql-key alist tree key)
                    (sublis-test-key alist tree test key)))
            (if test-not
  	      (sublis-test-not-key alist tree test-not key)
                (sublis-eql-key alist tree key)))
        (if test
            (if (or (eq test #'eq) (eq test 'eq))
  