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: 
  (defmacro defun/cc (name arguments &body body)
    `(progn
       (setf (get ',name 'defun/cc) (make-instance 'cps-closure
                                                   :code (walk-form '(lambda ,arguments ,@body) nil nil)
                                                   :env nil))
       (defun ,name ,arguments
  
negative.code:       (kontinue k value)
        (throw 'done value)))
  
  (defmethod evaluate/cc ((func free-application-form) env k)
    (cond 
      ((eql 'call/cc (operator func))
       (evaluate/cc (make-instance 'free-application-form
                                    :operator 'funcall
                                    :arguments (list (first (arguments func)) (make-instance 'constant-form :value k :source k))
                                    :source (source func))
  