anchor.diff:                     &body body)
     (cond
       (other-values-p `(lambda (,value &rest ,other-values)
  -                       (lambda () ,@body)))
  +                       (lambda ()
  +                         (when *debug-evaluate/cc*
  +                           (format *debug-io* "~&Got (values ~S~{~^ ~S~}).~%"
  +                                   ,value ,other-values))
  +                         ,@body)))
       (valuep `(lambda (,value &rest ,other-values)
                  (declare (ignore ,other-values))
  -               (lambda () ,@body)))
  +               (lambda ()
  +                 (when *debug-evaluate/cc*
  +                   (format *debug-io* "~&Got ~S.~%"
  +                           ,value))
  +                 ,@body)))
       (t `(lambda (,value &rest ,other-values)
  -          (declare (ignore ,value ,other-values))
  -          (lambda () ,@body)))))
  +          (lambda ()
  +            (when *debug-evaluate/cc*
  +              (format *debug-io* "~&Ignoring (values ~S~{~^ ~S~}).~%"
  +                      ,value ,other-values))
  +            ,@body)))))
   
   (defun kontinue (k &optional (primary-value nil primary-value-p)
                    &rest other-values)
  
positive.code: (defun (setf fdefinition/cc) (closure-object function-name)
    (setf (gethash function-name *cc-functions*) closure-object))
  
  ;;;; Implementation
  
  (defun drive-interpreter/cc (code)
  
negative.code:      (klambda ,k-args ,@body)))
  
  (defgeneric evaluate/cc (form env k))
  
  (defun print-debug-step (form env k)
    (let ((*print-pretty* nil))
      (ecase *debug-evaluate/cc*
        (:full
         (format *debug-io*
                 "~&Evaluating: ~S~%Env: ~S~%K: ~S~%"
                 form env k))
        ((t)
         (format *debug-io* "~&Evaluating: ~S~%" form))
        ((nil) ;; do nothing
         nil))))
  
  (defmethod evaluate/cc :before (form env k)
    (when *debug-evaluate/cc*
      (print-debug-step form env k)))
  
  (defvar *k*)
  
  