anchor.diff:        (let ((a list)
               (b (cdr list))
               (c (cddr list)))
  -        (loop until (atom c)
  +        (loop for slow on list
  +	      until (atom c)
                 do (setf a b
                          b c
  -                       c (cdr c)))
  -        (setf (cdr a) nil)
  +                       c (cdr c))
  +	      until (atom c)
  +              do (setf a b
  +                       b c
  +                       c (cdr c))
  +	      do (when (eq slow c)
  +		   ;; we have a circular list
  +		   (error 'must-be-proper-or-dotted-list
  +			  :datum list
  +			  :name 'nbutlast)))
  +	(setf (cdr a) nil)
           list)))
   
   ;;; FIXME: The HyperSpec says that we must signal a type-error
  
positive.code: ;;; This implementation works according to the HyperSpec note
  ;;; when n is 0.
  
  ;;; FIXME: The HyperSpec says that we must signal a type-error
  ;;; for circular lists, but we currently don't. 
  
  (defun butlast (list &optional (n 1))
    (unless (typep list 'list)
      (error 'must-be-list
  
negative.code: 	   :name 'nbutlast))
    (if (= n 1)
        (nbutlast-1 list)
        (let ((length (loop for slow on list
  			  with conses = list
                            until (atom conses)
                            count t
  			  do (setf conses (cdr conses))
                            until (atom conses)
                            count t
  			  do (setf conses (cdr conses))
  			  do (when (eq slow conses)
  			       ;; we have a circular list
  			       (error 'must-be-proper-or-dotted-list
  				      :datum list
  				      :name 'nbutlast)))))
          (if (<= length n)
              nil
              (progn (setf (cdr (nthcdr (- length (1+ n)) list)) nil)
  