anchor.diff:        (arguments func) '()
         env))))
   
  -(defmethod evaluate/cps ((func local-application-form) env k)
  -  (evaluate/cps-apply (arguments func) (list (list (lookup env :flet (operator func) :error-p t))) env k))
  -
  -(defk k-for-cps-apply (remaining-arguments evaluated-arguments env k)
  -    (value)
  -  (evaluate/cps-apply (cdr remaining-arguments) (cons value evaluated-arguments)
  -                      env k))
  -
  -(defun evaluate/cps-apply (remaining-arguments evaluated-arguments env k)
  +(defmethod evaluate/cc ((func local-application-form) env k)
  +  (evaluate-apply/cc (arguments func) (list (list (lookup env :flet (operator func) :error-p t))) env k))
  +
  +(defk k-for-apply/cc (remaining-arguments evaluated-arguments env k)
  +    (value)
  +  (evaluate-apply/cc (cdr remaining-arguments) (cons value evaluated-arguments)
  +                     env k))
  +
  +(defun evaluate-apply/cc (remaining-arguments evaluated-arguments env k)
     (if remaining-arguments
  -      (evaluate/cps (car remaining-arguments) env
  -                    `(k-for-cps-apply ,remaining-arguments ,evaluated-arguments ,env ,k))
  +      (evaluate/cc (car remaining-arguments) env
  +                    `(k-for-apply/cc ,remaining-arguments ,evaluated-arguments ,env ,k))
         (let ((arg-list (apply #'list* (reverse evaluated-arguments))))
  -        (apply-cps-lambda (first arg-list) (rest arg-list) k))))
  -
  -(defun evaluate/cps-funcall (arguments env k)
  -  (evaluate/cps-apply (append (butlast arguments)
  -                              (list (make-instance 'free-application-form
  -                                                   :operator 'list
  -                                                   :source `(list ,(source (car (last arguments))))
  -                                                   :arguments (last arguments))))
  -                      '()
  -                      env k))
  -
  -(defmethod apply-cps-lambda ((operator cps-closure) effective-arguments k)
  +        (apply-lambda/cc (first arg-list) (rest arg-list) k))))
  +
  +(defun evaluate-funcall/cc (arguments env k)
  +  (evaluate-apply/cc (append (butlast arguments)
  +                             (list (make-instance 'free-application-form
  +                                                  :operator 'list
  +                                                  :source `(list ,(source (car (last arguments))))
  +                                                  :arguments (last arguments))))
  +                     '()
  +                     env k))
  +
  +(defmethod apply-lambda/cc ((operator closure/cc) effective-arguments k)
     (let ((env (env operator))
           (remaining-arguments effective-arguments)
           (remaining-parameters (arguments (code operator))))
  
positive.code:     ()
    (kontinue k nil))
  
  (defmethod evaluate/cps ((tagbody tagbody-form) env k)
    (evaluate/cps-progn (body tagbody) (register env :tag tagbody k) `(tagbody-k ,k)))
  
  (defmethod evaluate/cps ((go-tag go-tag-form) env k)
    (declare (ignore go-tag env))
    (kontinue k nil))
  
  (defmethod evaluate/cps ((go go-form) env k)
    (declare (ignore k))
    (evaluate/cps-progn (target-progn go) env (lookup env :tag (enclosing-tagbody go) :error-p t)))
  
  ;;;; THE
  
  (defmethod evaluate/cps ((the the-form) env k)
    (evaluate/cps (value the) env k))
  
  ;;;; DEFUN/CC and DEFMETHOD/CC
  
  
negative.code: This function can be used within the lexcial scope of
  with-call/cc and outside, though it has slightly different
  semantics."
    (drive-interpreter/cc
     (lambda ()
       (let ((k (apply (car k) (cdr k))))
         (cond
           (other-values (apply k primary-value other-values))
           (primary-value-p (funcall k primary-value))
           (t (funcall k nil)))))))
  
  ;;;; Implementation
  
  (defun drive-interpreter/cc (code)
    (catch 'done
      (loop for thunk = code then (funcall thunk))))
  
  (defmacro let/cc (k &body body)
    `(call/cc (lambda (,k) ,@body)))
  