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: 
  (defun evaluate-m-v-c (remaining-arguments evaluated-arguments env k)
    (if remaining-arguments
        (evaluate/cps (car remaining-arguments) env
                      `(k-for-m-v-c  ,(cdr remaining-arguments) ,evaluated-arguments ,env ,k))
        (destructuring-bind (function &rest arguments)
            evaluated-arguments
          (etypecase function
            (cps-closure (apply-cps-lambda function evaluated-arguments k))
            (function (apply #'kontinue k (multiple-value-list
                                           (multiple-value-call function (values-list arguments)))))))))
  
  (defmethod evaluate/cps ((m-v-c multiple-value-call-form) env k)
    (evaluate-m-v-c (list* (func m-v-c) (arguments m-v-c)) '() env k))
  
  ;;;; PROGN
  
  (defmethod evaluate/cps ((progn progn-form) env k)
    (evaluate/cps-progn (body progn) env k))
  
  (defk k-for-evaluate/cps-progn (rest-of-body env k)
      ()
    (evaluate/cps-progn rest-of-body env k))
  
  (defun evaluate/cps-progn (body env k)
    (cond
      ((cdr body)
        (evaluate/cps (first body) env
                      `(k-for-evaluate/cps-progn ,(cdr body) ,env ,k)))
      (body
       (evaluate/cps (first body) env k))
      (t
       (kontinue k nil))))
  
  
negative.code:                         ,env
                          ,k)))
        (dolist* ((var . value) evaluated-bindings
                  (evaluate-progn/cc body env k))
          (setf env (register env :let var value)))))
  
  (defmethod evaluate/cc ((let* let*-form) env k)
    (evaluate-let*/cc (binds let*) (body let*) env k))
  
  (defk k-for-evaluate-let*/cc (var bindings body env k)
      (value)
    (evaluate-let*/cc bindings body
                       (register env :let var value) k))
  
  (defun evaluate-let*/cc (bindings body env k)
    (if bindings
        (destructuring-bind (var . initial-value)
            (car bindings)
          (evaluate/cc initial-value env
                        `(k-for-evaluate-let*/cc ,var ,(cdr bindings) ,body ,env ,k)))
        (evaluate-progn/cc body env k)))
  
  ;;;; IF
  
  (defk k-for-evaluate-if/cc (then else env k)
      (value)
    (if value
        (evaluate/cc then env k)
        (evaluate/cc else env k)))
  
  (defmethod evaluate/cc ((if if-form) env k)
    (evaluate/cc (consequent if) env
                  `(k-for-evaluate-if/cc ,(then if) ,(else if) ,env ,k )))
  
  ;;;; LOCALLY
  
  (defmethod evaluate/cc ((locally locally-form) env k)
    (evaluate-progn/cc (body locally) env k))
  
  ;;;; MACROLET
  
  (defmethod evaluate/cc ((macrolet macrolet-form) env k)
    (evaluate-progn/cc (body macrolet) env k))
  
  ;;;; multiple-value-call
  
  