anchor.diff:  ;;; eq elements of the list, so we might as well take the first one
   ;;; as in the case from-end=false
   
  -(defun |find seq-type=list from-end=true end=nil test=eq key=other|
  -    (item list start key)
  -  (loop with value = nil
  -        for remaining = (skip-to-start 'find list start) then (cdr remaining)
  -	until (atom remaining)
  -	for element = (car remaining)
  -        when (eq item (funcall key element))
  -          do (setf value element)
  -        finally (tail-must-be-proper-list 'find list remaining)
  -		(return value)))
  -
  -(defun |find seq-type=list from-end=true end=nil test-not=eq key=identity|
  -    (item list start)
  -  (loop with value = nil
  -        for remaining = (skip-to-start 'find list start) then (cdr remaining)
  -	until (atom remaining)
  -	for element = (car remaining)
  -        when (not (eq item element))
  -          do (setf value element)
  -        finally (tail-must-be-proper-list 'find list remaining)
  -		(return value)))
  -
  -(defun |find seq-type=list from-end=true end=nil test-not=eq key=other|
  -    (item list start key)
  -  (loop with value = nil
  -        for remaining = (skip-to-start 'find list start) then (cdr remaining)
  -	until (atom remaining)
  -	for element = (car remaining)
  -        when (not (eq item (funcall key element)))
  -          do (setf value element)
  -        finally (tail-must-be-proper-list 'find list remaining)
  -		(return value)))
  +(define-find-list-variant :from-end true :end nil :test eq :key other)
  +(define-find-list-variant :from-end true :end nil :test-not eq :key identity)
  +(define-find-list-variant :from-end true :end nil :test-not eq :key other)
   
   ;;; We do not supply a special version for
   ;;; seq-type=list from-end=true end=nil test=eql key=identity
  
positive.code: ;;;
  ;;; Function find
  
  (defun |find seq-type=list from-end=false end=nil test=eq key=identity|
      (item list start)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (eq item element)
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test=eq key=other|
      (item list start key)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (eq item (funcall key element))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test-not=eq key=identity|
      (item list start)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (not (eq item element))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test-not=eq key=other|
      (item list start key)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (not (eq item (funcall key element)))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test=eql key=identity|
      (item list start)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (eql item element)
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test=eql key=other|
      (item list start key)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (eql item (funcall key element))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test-not=eql key=identity|
      (item list start)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (not (eql item element))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test-not=eql key=other|
      (item list start key)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (not (eql item (funcall key element)))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test=other key=identity|
      (item list start test)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (funcall test item element)
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test=other key=other|
      (item list start test key)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (funcall test item (funcall key element))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test-not=other key=identity|
      (item list start test)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (not (funcall test item element))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=nil test-not=other key=other|
      (item list start test key)
    (loop for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (atom remaining)
  	for element = (car remaining)
          when (not (funcall test item (funcall key element)))
            return element
  	finally (tail-must-be-proper-list 'find list remaining)))
  
  (defun |find seq-type=list from-end=false end=other test=eq key=identity|
      (item list start end)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (eq item element)
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test=eq key=other|
      (item list start end key)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (eq item (funcall key element))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test-not=eq key=identity|
      (item list start end)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (not (eq item element))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test-not=eq key=other|
      (item list start end key)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (not (eq item (funcall key element)))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test=eql key=identity|
      (item list start end)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (eql item element)
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test=eql key=other|
      (item list start end key)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (eql item (funcall key element))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test-not=eql key=identity|
      (item list start end)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (not (eql item element))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test-not=eql key=other|
      (item list start end key)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (not (eql item (funcall key element)))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test=other key=identity|
      (item list start end test)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (funcall test item element)
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test=other key=other|
      (item list start end test key)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (funcall test item (funcall key element))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test-not=other key=identity|
      (item list start end test)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (not (funcall test item element))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  (defun |find seq-type=list from-end=false end=other test-not=other key=other|
      (item list start end test key)
    (loop for index from start
  	for remaining = (skip-to-start 'find list start) then (cdr remaining)
  	until (or (atom remaining) (>= index end))
  	for element = (car remaining)
          when (not (funcall test item (funcall key element)))
            return element
  	finally (tail-must-be-proper-list-with-end
  		     'find list remaining end index)))
  
  ;;; We do not supply a special version for
  ;;; seq-type=list from-end=true end=nil test=eq key=identity
  
negative.code: ;;; eq elements of the list, so we might as well take the first one
  ;;; as in the case from-end=false
  
  (define-find-list-variant :from-end true :end other :test eq :key other)
  (define-find-list-variant :from-end true :end other :test-not eq :key identity)
  (define-find-list-variant :from-end true :end other :test-not eq :key other)
  
  ;;; We do not supply a special version for
  ;;; seq-type=list from-end=true end=other test=eql key=identity
  