anchor.diff:         (go b) (reached-unreachable-code)
        c
          (pass)))
  -  (with-call/cc ()
  +  (with-call/cc
       (let ((counter 0))
         (dotimes (i 5)
           (incf counter))
         (is (= 5 counter))))
  -  (with-call/cc ()
  +  (with-call/cc
       (let ((i 0))
         (tagbody
          a (incf i) (is (= 1 i))
  
positive.code:   (setf *call/cc-returns* nil))
  
  (test cps-constant
    (is (= 4 (with-call/cc () 4)))
    (is (eql :a (with-call/cc () :a)))
    (is (eql 'a (with-call/cc () 'a)))
    (is (eql #'+ (with-call/cc () #'+))))
  
  (test cps-progn
    (is (null (with-call/cc ())))
    (is (= 1 (with-call/cc () 1)))
    (is (= 2 (with-call/cc () 1 2)))
    (is (= 3 (with-call/cc () 1 2 3)))
    (is (= 4 (with-call/cc () 1 2 3 4))))
  
  (test cps-progn/cc
    (is (= 1 (kall (with-call/cc () (let/cc k k) 1))))
    (is (= 1 (kall (with-call/cc () (let/cc k k) 0 1)))))
  
  (test cps-let
    (is (= 1 (with-call/cc ()
  	    (let () 1))))
    (is (= 1 (with-call/cc ()
  	    (let ((a 1)) a))))
    (is (= 1 (with-call/cc ()
               (let ((a 4)
                     (b a))
                 (declare (ignore a))
                 b))))
    (is (= 4 (with-call/cc ()
               (let ((a 4)
                     (b a))
                 (declare (ignore b))
                 a))))
    (with-call/cc ()
      (let ((a 1))
        (let ((a 2))
          (is (= 2 a)))
        (is (= 1 a)))))
  
  (test cps-let/cc
    (let ((k (with-call/cc ()
               (let ((a (retk)))
                 (+ a 1)))))
    (is (= 1 (kall k 0)))
    (is (= 2 (kall k 1)))))
  
  (test cps-setq
    (is (= 1 (with-call/cc ()
               (let ((a nil)) (setq a 1)))))
    (is (= 2 (with-call/cc ()
               (let ((a 1)) (setq a (1+ a)))))))
  
  (test cps-let*
    (with-call/cc ()
      (let* ((a 1)
  	   (b a))
        (is (= 1 a))
        (is (= 1 b))))
    (with-call/cc ()
     (let ((a 0)
  	 (b 1))
       (declare (ignore a))
  
negative.code:        (is (= a 47))))))
  
  (test cps-apply
    (is (= 0 (with-call/cc (+))))
    (is (= 1 (with-call/cc (+ 1))))
    (is (= 2 (with-call/cc (+ 1 1))))
    (is (= 3 (with-call/cc (+ 1 (+ 1 (+ 1 (+))))))))
  
  (test cps-if
    (is (= 1 (with-call/cc (if t 1))))
    (is (= 1 (with-call/cc (if nil 0 1))))
    (is (null (with-call/cc (if nil 1)))))
  
  (test cps-block/return-from
    (is (= 1
           (with-call/cc
             (block foo
                 nil
                 (return-from foo 1)
                 nil))))
    (is (eql t 
             (with-call/cc
                 (block foo
                   (return-from foo t)
                   nil)))))
  