anchor.diff:        (kontinue k value)
         (throw 'done value)))
   
  -(defmethod evaluate/cps ((func free-application-form) env k)
  +(defmethod evaluate/cc ((func free-application-form) env k)
     (cond 
       ((eql 'call/cc (operator func))
  -     (evaluate/cps (make-instance 'free-application-form
  +     (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))
  
positive.code: 
  (defun evaluate-arguments-then-apply (handler remaining-arguments evaluated-arguments env)
    (if remaining-arguments
        (evaluate/cps (car remaining-arguments) env
                      `(k-for-evaluate-arguments-then-apply ,handler ,(cdr remaining-arguments)
                                                            ,evaluated-arguments ,env))
        (funcall handler (reverse evaluated-arguments))))
  
  ;;;; FUNCTION and LAMBDA application
  
  (defmethod evaluate/cps ((lambda lambda-application-form) env k)
    (evaluate/cps-funcall (cons (operator lambda) (arguments lambda)) env k))
  
  ;;;; Constants
  
  (defmethod evaluate/cps ((c constant-form) env k)
    (declare (ignore env))
    (kontinue k (value c)))
  
  ;;;; BLOCK/RETURN-FROM
  
  (defmethod evaluate/cps ((block block-form) env k)
    (evaluate/cps-progn (body block) (register env :block (name block) k) k))
  
  (defmethod evaluate/cps ((return return-from-form) env k)
    (declare (ignore k))
    (evaluate/cps (result return) env (lookup env :block (name (target-block return)) :error-p t)))
  
  ;;;; CATCH/THROW
  
  (defk catch-tag-k (catch env k)
      (tag)
    (evaluate/cps-progn (body catch) (register env :catch tag k) k))
  
  (defmethod evaluate/cps ((catch catch-form) env k)
    (evaluate/cps (tag catch) env `(catch-tag-k ,catch ,env ,k)))
  
  (defk throw-tag-k (throw env k)
      (tag)
    (evaluate/cps (value throw) env (lookup env :catch tag :error-p t)))
  
  (defmethod evaluate/cps ((throw throw-form) env k)
    (evaluate/cps (tag throw) env
                  `(throw-tag-k ,throw ,env ,k)))
  
  ;;;; FLET/LABELS
  
  (defmethod evaluate/cps ((flet flet-form) env k)
    (let ((new-env env))
      (dolist* ((name . form) (binds flet))
        (setf new-env (register new-env :flet name (make-instance 'cps-closure
                                                                  :code form
                                                                  :env env))))
      (evaluate/cps-progn (body flet) new-env k)))
  
  (defmethod evaluate/cps ((labels labels-form) env k)
    (let ((closures '()))
      (dolist* ((name . form) (binds labels))
        (let ((closure (make-instance 'cps-closure :code form)))
          (setf env (register env :flet name closure))
          (push closure closures)))
      (dolist (closure closures)
        (setf (env closure) env))
      (evaluate/cps-progn (body labels) env k)))
  
  ;;;; LET/LET*
  
  (defmethod evaluate/cps ((let let-form) env k)
    (evaluate/cps-let (binds let) nil (body let) env k))
  
  (defk k-for-evaluate/cps-let (var remaining-bindings evaluated-bindings body env k)
      (value)
    (evaluate/cps-let remaining-bindings
                      (cons (cons var value) evaluated-bindings)
                      body env k))
  
  (defun evaluate/cps-let (remaining-bindings evaluated-bindings body env k)
    (if remaining-bindings
        (destructuring-bind (var . initial-value)
            (car remaining-bindings)
          (evaluate/cps initial-value env
                        `(k-for-evaluate/cps-let
                          ,var
                          ,(cdr remaining-bindings)
                          ,evaluated-bindings
  
negative.code:       (arguments func) '()
        env))))
  
  (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/cc (car remaining-arguments) env
                      `(k-for-apply/cc ,remaining-arguments ,evaluated-arguments ,env ,k))
        (let ((arg-list (apply #'list* (reverse evaluated-arguments))))
          (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))))
  