anchor.diff:  	(if test
   	    (cond ((or (eq test #'eq) (eq test 'eq))
   		   (if use-hash
  -		       (union-key-eq-hash list1 list2 key)
  -		       (union-key-eq list1 list2 key)))
  +		       (union-key-eq-hash 'union list1 list2 key)
  +		       (union-key-eq 'union list1 list2 key)))
   		  ((or (eq test #'eql) (eq test 'eql))
   		   (if use-hash
  -		       (union-key-eql-hash list1 list2 key)
  -		       (union-key-eql list1 list2 key)))
  +		       (union-key-eql-hash 'union list1 list2 key)
  +		       (union-key-eql 'union list1 list2 key)))
   		  ((or (eq test #'equal) (eq test 'equal))
   		   (if use-hash
  -		       (union-key-equal-hash list1 list2 key)
  -		       (union-key-test list1 list2 key #'equal)))
  +		       (union-key-equal-hash 'union list1 list2 key)
  +		       (union-key-test 'union list1 list2 key #'equal)))
   		  ((or (eq test #'equalp) (eq test 'equalp))
   		   (if use-hash
  -		       (union-key-equalp-hash list1 list2 key)
  -		       (union-key-test list1 list2 key #'equalp)))
  +		       (union-key-equalp-hash 'union list1 list2 key)
  +		       (union-key-test 'union list1 list2 key #'equalp)))
   		  (t
  -		   (union-key-test list1 list2 key test)))
  +		   (union-key-test 'union list1 list2 key test)))
   	    (if test-not
  -		(union-key-test-not list1 list2 key test-not)
  +		(union-key-test-not 'union list1 list2 key test-not)
   		(if use-hash
  -		    (union-key-eql-hash list1 list2 key)
  -		    (union-key-eql list1 list2 key))))
  +		    (union-key-eql-hash 'union list1 list2 key)
  +		    (union-key-eql 'union list1 list2 key))))
   	(if test
   	    (cond ((or (eq test #'eq) (eq test 'eq))
   		   (if use-hash
  -		       (union-identity-eq-hash list1 list2)
  -		       (union-identity-eq list1 list2)))
  +		       (union-identity-eq-hash 'union list1 list2)
  +		       (union-identity-eq 'union list1 list2)))
   		  ((or (eq test #'eql) (eq test 'eql))
   		   (if use-hash
  -		       (union-identity-eql-hash list1 list2)
  -		       (union-identity-eql list1 list2)))
  +		       (union-identity-eql-hash 'union list1 list2)
  +		       (union-identity-eql 'union list1 list2)))
   		  ((or (eq test #'equal) (eq test 'equal))
   		   (if use-hash
  -		       (union-identity-equal-hash list1 list2)
  -		       (union-identity-test list1 list2 #'equal)))
  +		       (union-identity-equal-hash 'union list1 list2)
  +		       (union-identity-test 'union list1 list2 #'equal)))
   		  ((or (eq test #'equalp) (eq test 'equalp))
   		   (if use-hash
  -		       (union-identity-equalp-hash list1 list2)
  -		       (union-identity-test list1 list2 #'equalp)))
  +		       (union-identity-equalp-hash 'union list1 list2)
  +		       (union-identity-test 'union list1 list2 #'equalp)))
   		  (t
  -		   (union-identity-test list1 list2 test)))
  +		   (union-identity-test 'union list1 list2 test)))
   	    (if test-not
  -		(union-identity-test-not list1 list2 test-not)
  +		(union-identity-test-not 'union list1 list2 test-not)
   		(if use-hash
  -		    (union-identity-eql-hash list1 list2)
  -		    (union-identity-eql list1 list2)))))))
  +		    (union-identity-eql-hash 'union list1 list2)
  +		    (union-identity-eql 'union list1 list2)))))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  
positive.code: ;;;
  ;;; Function union
  
  (defun union-identity-eql (list1 list2)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(when (eql (car rest1) (car rest2))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-identity-eq (list1 list2)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(when (eq (car rest1) (car rest2))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-key-eql (list1 list2 key)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(when (eql (funcall key (car rest1)) (funcall key (car rest2)))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-key-eq (list1 list2 key)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(when (eq (funcall key (car rest1)) (funcall key (car rest2)))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-identity-test (list1 list2 test)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(when (funcall test (car rest1) (car rest2))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-key-test (list1 list2 key test)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(when (funcall test (funcall key (car rest1)) (funcall key (car rest2)))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-identity-test-not (list1 list2 test-not)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(unless (funcall test-not
  				 (car rest1)
  				 (car rest2))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-key-test-not (list1 list2 key test-not)
    (let ((result list2))
      (with-proper-list-rests (rest1 list1 union)
        (unless (with-proper-list-rests (rest2 list2 union)
  		(unless (funcall test-not
  				 (funcall key (car rest1))
  				 (funcall key (car rest2)))
  		  (return t)))
  	(push (car rest1) result)))
      result))
  
  (defun union-identity-eq-hash (list1 list2)
    (let ((table (make-hash-table :test #'eq)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-identity-eql-hash (list1 list2)
    (let ((table (make-hash-table :test #'eql)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-identity-equal-hash (list1 list2)
    (let ((table (make-hash-table :test #'equal)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-identity-equalp-hash (list1 list2)
    (let ((table (make-hash-table :test #'equalp)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash element table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-key-eq-hash (list1 list2 key)
    (let ((table (make-hash-table :test #'eq)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-key-eql-hash (list1 list2 key)
    (let ((table (make-hash-table :test #'eql)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-key-equal-hash (list1 list2 key)
    (let ((table (make-hash-table :test #'equal)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  (defun union-key-equalp-hash (list1 list2 key)
    (let ((table (make-hash-table :test #'equalp)))
      (with-proper-list-rests (rest list1 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (with-proper-list-rests (rest list2 union)
        (let ((element (car rest)))
  	(setf (gethash (funcall key element) table) element)))
      (loop for element being the hash-values of table
  	  collect element)))
  
  
negative.code: 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Some helper macros
  
  (defmacro with-proper-list-rests ((rest-var list function-name) &body body)
    (let ((list-var (gensym)))
  