anchor.diff:                   (return-from nth-from-end (first a))))
              list (nthcdr n list)))
   
  -(defun nth-from-end.tests ()
  -  (assert (equal (nth-from-end 0 (integer-range 10))
  +(let ((0-to-10 '(0 1 2 3 4 5 6 7 8 9 10)))
  +  (assert (equal (nth-from-end 0 0-to-10)
                    10))
  -  (assert (equal (nth-from-end 3 (integer-range 10))
  +  (assert (equal (nth-from-end 3 0-to-10)
                    7))
  -  (assert (equal (nth-from-end 10 (integer-range 10))
  +  (assert (equal (nth-from-end 10 0-to-10)
                    0))
  -  (assert (equal (nth-from-end 11 (integer-range 10))
  +  (assert (equal (nth-from-end 11 0-to-10)
                    nil)))
   
   (defmacro swap (x y)
  
positive.code:                   (< i stop)))
           (reverse range))))))
  
  (defun integer-range.tests ()
    (assert (equal (integer-range 5)
                   '(0 1 2 3 4 5)))
    (assert (equal (integer-range 5 10)
                   '(5 6 7 8 9 10)))
    (assert (equal (integer-range 5 10 2)
                   '(5 7 9)))
    (assert (equal (integer-range -5)
                   '(0 -1 -2 -3 -4 -5)))
    (assert (equal (integer-range -5 0)
                   '(-5 -4 -3 -2 -1 0)))
    (assert (equal (integer-range 10 5)
                   '(10 9 8 7 6 5)))
    (assert (equal (integer-range 10 5 1)
                   nil))
    (assert (equal (integer-range 5 10 -1)
                   nil))
    (assert (equal (integer-range -5 5)
                   '(-5 -4 -3 -2 -1 0 1 2 3 4 5)))
    (assert (equal (integer-range -5 5 2)
                   '(-5 -3 -1 1 3 5))))
  
  (defmacro forever (&rest body)
    `(while t ,@body))
  
negative.code:   `(psetf ,x ,y
            ,y ,x))
  
  (let ((x 15)
        (y 37))
    (swap x y)
    (assert (= y 15))
    (assert (= x 37)))
  
  (defmacro swap-when (predicate x y)
    "This macro calls SWAP only when the predicate evaluates to true."
  