anchor.diff:  
   ;;;; Variable References
   
  -(defmethod evaluate/cps ((var local-variable-reference) env k)
  +(defmethod evaluate/cc ((var local-variable-reference) env k)
     (kontinue k (lookup env :let (name var) :error-p t)))
   
  -(defmethod evaluate/cps ((var local-lexical-variable-reference) env k)
  +(defmethod evaluate/cc ((var local-lexical-variable-reference) env k)
     (kontinue k (funcall (first (lookup env :lexical-let (name var) :error-p t)))))
   
  -(defmethod evaluate/cps ((var free-variable-reference) env k)
  +(defmethod evaluate/cc ((var free-variable-reference) env k)
     (declare (ignore env))
     (kontinue k (symbol-value (name var))))
   
   ;;;; FUNCTION and LAMBDA form
   
  -(defmethod evaluate/cps ((func free-function-object-form) env k)
  +(defmethod evaluate/cc ((func free-function-object-form) env k)
     (declare (ignore env))
     (if (fboundp (name func))
         (kontinue k (fdefinition (name func)))
         (error "Unbound function ~S." (name func))))
   
  -(defmethod evaluate/cps ((func local-function-object-form) env k)
  +(defmethod evaluate/cc ((func local-function-object-form) env k)
     (kontinue k (lookup env :flet (name func) :error-p t)))
   
  -(defclass cps-closure ()
  +(defclass closure/cc ()
     ((code :accessor code :initarg :code)
      (env :accessor env :initarg :env)))
   
  -(defmethod evaluate/cps ((lambda lambda-function-form) env k)
  -  (kontinue k (make-instance 'cps-closure :code lambda :env env)))
  +(defmethod evaluate/cc ((lambda lambda-function-form) env k)
  +  (kontinue k (make-instance 'closure/cc :code lambda :env env)))
   
   (defk k-for-call/cc (k)
       (value)
  
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: 
  (defmacro defun/cc (name arguments &body body)
    `(progn
       (setf (get ',name 'defun/cc) (make-instance 'closure/cc
                                                   :code (walk-form '(lambda ,arguments ,@body) nil nil)
                                                   :env nil))
       (defun ,name ,arguments
  