anchor.diff:                 (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-cps-lambda
  +             (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/cps (default-value parameter) env
  -                             `(k-for-apply-cps/optional-argument-default-value
  -                               ;; remaining-arguments is, by
  -                               ;; definition, NIL so we needn't pass
  -                               ;; it here.
  -                               ,operator ,remaining-parameters ,env ,k)))))))
  +               (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/cps-progn (body (code operator)) env k)))
  -
  -(defk k-for-apply-cps/optional-argument-default-value
  +    (evaluate-progn/cc (body (code operator)) env k)))
  +
  +(defk k-for-apply-cc/optional-argument-default-value
       (operator remaining-parameters env k)
       (value)
  -  (apply-cps-lambda/optional-default-value
  +  (apply-lambda/cc/optional-default-value
      operator (cdr remaining-parameters)
      (register env :let (name (first remaining-parameters)) value) k))
   
  -(defun apply-cps-lambda/optional-default-value (operator remaining-parameters env 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-cps-lambda/optional-default-value
  -             (evaluate/cps (default-value parameter) env
  -                           `(k-for-apply-cps/optional-argument-default-value
  -                             ,operator ,(cdr remaining-parameters) ,env ,k))))
  +           (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/cps-progn (body (code operator)) env k)))
  -
  -(defmethod apply-cps-lambda ((operator function) effective-arguments k)
  +      (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)
  
positive.code:      (declare (ignorable ,@args))
       (klambda ,k-args ,@body)))
  
  (defgeneric evaluate/cps (form env k))
  
  (defvar *k*)
  
  
negative.code:      (setf (get ',name 'defmethod/cc) t)
       (defmethod ,name ,arguments
         (declare (ignorable ,@(extract-argument-names arguments :allow-specializers t)))
         (make-instance 'closure/cc
                        :code (walk-form '(lambda ,(extract-argument-names arguments :allow-specializers t
                                                                           :keep-lambda-keywords t)
                                           ,@body)
  