anchor.diff:  	    ((atom tree) tree)
   	    (t (traverse tree) tree)))))
   
  -;;; Special case when test-not is eq and key is identity
  -
  -(defun nsublis-not-eq-identity (alist tree)
  -  (labels ((traverse (tree)
  -             (let ((entry (assoc-not-eq-identity (car tree) alist)))
  -               (cond ((not (null entry)) (setf (car tree) (cdr entry)))
  -                     ((atom (car tree)) nil)
  -                     (t (traverse (car tree)))))
  -	     (let ((entry (assoc-not-eq-identity (cdr tree) alist)))
  -               (cond ((not (null entry)) (setf (cdr tree) (cdr entry)))
  -                     ((atom (cdr tree)) nil)
  -                     (t (traverse (cdr tree)))))))
  -    (let ((entry (assoc-not-eq-identity tree alist)))
  -      (cond ((not (null entry)) (cdr entry))
  -	    ((atom tree) tree)
  -	    (t (traverse tree) tree)))))
  -
  -;;; Special case when test-not is eql and key is identity
  -
  -(defun nsublis-not-eql-identity (alist tree)
  -  (labels ((traverse (tree)
  -             (let ((entry (assoc-not-eql-identity (car tree) alist)))
  -               (cond ((not (null entry)) (setf (car tree) (cdr entry)))
  -                     ((atom (car tree)) nil)
  -                     (t (traverse (car tree)))))
  -	     (let ((entry (assoc-not-eql-identity (cdr tree) alist)))
  -               (cond ((not (null entry)) (setf (cdr tree) (cdr entry)))
  -                     ((atom (cdr tree)) nil)
  -                     (t (traverse (cdr tree)))))))
  -    (let ((entry (assoc-not-eql-identity tree alist)))
  -      (cond ((not (null entry)) (cdr entry))
  -	    ((atom tree) tree)
  -	    (t (traverse tree) tree)))))
  -
  -;;; Special case when test-not is eq and key is given.
  -
  -(defun nsublis-not-eq-key (alist tree key)
  -  (labels ((traverse (tree)
  -             (let ((entry (assoc-not-eq-identity (funcall key (car tree))
  -						 alist)))
  -               (cond ((not (null entry)) (setf (car tree) (cdr entry)))
  -                     ((atom (car tree)) nil)
  -                     (t (traverse (car tree)))))
  -	     (let ((entry (assoc-not-eq-identity (funcall key (cdr tree))
  -						 alist)))
  -               (cond ((not (null entry)) (setf (cdr tree) (cdr entry)))
  -                     ((atom (cdr tree)) nil)
  -                     (t (traverse (cdr tree)))))))
  -    (let ((entry (assoc-not-eq-identity (funcall key tree) alist)))
  -      (cond ((not (null entry)) (cdr entry))
  -	    ((atom tree) tree)
  -	    (t (traverse tree) tree)))))
  -
  -;;; Special case when test-not is eql and key is given.
  -
  -(defun nsublis-not-eql-key (alist tree key)
  -  (labels ((traverse (tree)
  -             (let ((entry (assoc-not-eql-identity (funcall key (car tree))
  -						  alist)))
  -               (cond ((not (null entry)) (setf (car tree) (cdr entry)))
  -                     ((atom (car tree)) nil)
  -                     (t (traverse (car tree)))))
  -	     (let ((entry (assoc-not-eql-identity (funcall key (cdr tree))
  -						  alist)))
  -               (cond ((not (null entry)) (setf (cdr tree) (cdr entry)))
  -                     ((atom (cdr tree)) nil)
  -                     (t (traverse (cdr tree)))))))
  -    (let ((entry (assoc-not-eql-identity (funcall key tree) alist)))
  -      (cond ((not (null entry)) (cdr entry))
  -	    ((atom tree) tree)
  -	    (t (traverse tree) tree)))))
  -
  -;;; Special case when test-not is given and key is identity.
  -
   (defun nsublis-test-not-identity (alist tree test)
     (labels ((traverse (tree)
                (let ((entry (assoc-test-not-identity (car tree) alist (lambda (x y) (funcall test y x)))))
  
positive.code:                   (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-eql-identity alist tree)))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
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))
  