anchor.diff:  
   (defun evaluate-arguments-then-apply (handler remaining-arguments evaluated-arguments env)
     (if remaining-arguments
  -      (evaluate/cps (car remaining-arguments) env
  +      (evaluate/cc (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))
  +(defmethod evaluate/cc ((lambda lambda-application-form) env k)
  +  (evaluate-funcall/cc (cons (operator lambda) (arguments lambda)) env k))
   
   ;;;; Constants
   
  -(defmethod evaluate/cps ((c constant-form) env k)
  +(defmethod evaluate/cc ((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)
  +(defmethod evaluate/cc ((block block-form) env k)
  +  (evaluate-progn/cc (body block) (register env :block (name block) k) k))
  +
  +(defmethod evaluate/cc ((return return-from-form) env k)
     (declare (ignore k))
  -  (evaluate/cps (result return) env (lookup env :block (name (target-block return)) :error-p t)))
  +  (evaluate/cc (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)))
  +  (evaluate-progn/cc (body catch) (register env :catch tag k) k))
  +
  +(defmethod evaluate/cc ((catch catch-form) env k)
  +  (evaluate/cc (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
  +  (evaluate/cc (value throw) env (lookup env :catch tag :error-p t)))
  +
  +(defmethod evaluate/cc ((throw throw-form) env k)
  +  (evaluate/cc (tag throw) env
                   `(throw-tag-k ,throw ,env ,k)))
   
   ;;;; FLET/LABELS
   
  -(defmethod evaluate/cps ((flet flet-form) env k)
  +(defmethod evaluate/cc ((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
  +      (setf new-env (register new-env :flet name (make-instance 'closure/cc
                                                                   :code form
                                                                   :env env))))
  -    (evaluate/cps-progn (body flet) new-env k)))
  -
  -(defmethod evaluate/cps ((labels labels-form) env k)
  +    (evaluate-progn/cc (body flet) new-env k)))
  +
  +(defmethod evaluate/cc ((labels labels-form) env k)
     (let ((closures '()))
       (dolist* ((name . form) (binds labels))
  -      (let ((closure (make-instance 'cps-closure :code form)))
  +      (let ((closure (make-instance 'closure/cc :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)))
  +    (evaluate-progn/cc (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)
  +(defmethod evaluate/cc ((let let-form) env k)
  +  (evaluate-let/cc (binds let) nil (body let) env k))
  +
  +(defk k-for-evaluate-let/cc (var remaining-bindings evaluated-bindings body env k)
  +    (value)
  +  (evaluate-let/cc remaining-bindings
  +                   (cons (cons var value) evaluated-bindings)
  +                   body env k))
  +
  +(defun evaluate-let/cc (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
  +        (evaluate/cc
  +         initial-value env
  +                      `(k-for-evaluate-let/cc
                           ,var
                           ,(cdr remaining-bindings)
                           ,evaluated-bindings
  
positive.code:       env))
      
      ((eql 'funcall (operator func))
       (evaluate/cps-funcall (arguments func) env k))
      
      ((eql 'apply (operator func))
       (evaluate/cps-apply   (arguments func) '() env k))
      
      ((and (symbolp (operator func))
            (get (operator func) 'defun/cc))
       (evaluate-arguments-then-apply
        (lambda (arguments)
          (apply-cps-lambda (get (operator func) 'defun/cc) arguments k))
        (arguments func) '()
        env))
  
  
negative.code:                (setf env (register env :let (name parameter) (pop remaining-arguments)))
                 (when (supplied-p-parameter parameter)
                   (setf env (register env :let (supplied-p-parameter parameter) t))))
               (return-from apply-lambda/cc
                 ;; we need to evaluate a default-value, since this may
                 ;; contain call/cc we need to setup the continuation
                 ;; and let things go from there (hence the return-from)
                 (evaluate/cc (default-value parameter) env
                              `(k-for-apply/cc/optional-argument-default-value
                                ;; remaining-arguments is, by
                                ;; definition, NIL so we needn't pass
                                ;; it here.
                                ,operator ,remaining-parameters ,env ,k)))))))
      
      (evaluate-progn/cc (body (code operator)) env k)))
  
  (defk k-for-apply-cc/optional-argument-default-value
      (operator remaining-parameters env k)
      (value)
    (apply-lambda/cc/optional-default-value
     operator (cdr remaining-parameters)
     (register env :let (name (first remaining-parameters)) value) k))
  
  (defun apply-lambda/cc/optional-default-value (operator remaining-parameters env k)
    (if remaining-parameters
        (dolist (parameter remaining-parameters)
          (typecase parameter
            (optional-function-argument-form
             (return-from apply-lambda/cc/optional-default-value
               (evaluate/cc (default-value parameter) env
                            `(k-for-apply/cc-optional-argument-default-value
                              ,operator ,(cdr remaining-parameters) ,env ,k))))
            (t (error "Sorry, only required and optional arguments for now."))))
        (evaluate-progn/cc (body (code operator)) env k)))
  
  (defmethod apply-lambda/cc ((operator function) effective-arguments k)
    (apply #'kontinue k (multiple-value-list (apply operator effective-arguments))))
  
  (defk k-for-evaluate-arguments-then-apply (handler remaining-arguments evaluated-arguments env)
  