anchor.diff:            (get (operator func) 'defmethod/cc))
        (evaluate-arguments-then-apply
         (lambda (arguments)
  -        (apply-cps-lambda (apply (fdefinition (operator func)) arguments) arguments k))
  +        (apply-lambda/cc (apply (fdefinition (operator func)) arguments) arguments k))
         (arguments func) '()
         env))
          
  
positive.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-cps-lambda
                 ;; 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/cps-progn (body (code operator)) env k)))
  
  (defk k-for-apply-cps/optional-argument-default-value
      (operator remaining-parameters env k)
      (value)
    (apply-cps-lambda/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)
    (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))))
            (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)
    (apply #'kontinue k (multiple-value-list (apply operator effective-arguments))))
  
  (defk k-for-evaluate-arguments-then-apply (handler remaining-arguments evaluated-arguments env)
  
negative.code:   (funcall (second (lookup env :lexical-let var :error-p t)) value)
    (kontinue k value))
  
  (defmethod evaluate/cc ((setq setq-form) env k)
    (multiple-value-bind (value foundp)
        (lookup env :let (var setq))
      (declare (ignore value))
      (if foundp
          (evaluate/cc (value setq)
                        env `(k-for-local-setq ,(var setq) ,env ,k))
          (multiple-value-bind (value foundp)
              (lookup env :lexical-let (var setq))
            (declare (ignore value))
            (if foundp
                (evaluate/cc (value setq)
                              env `(k-for-local-lexical-setq ,(var setq) ,env ,k))
                (evaluate/cc (value setq)
                              env `(k-for-free-setq ,(var setq) ,env ,k)))))))
  
  ;;;; SYMBOL-MACROLET
  
  (defmethod evaluate/cc ((symbol-macrolet symbol-macrolet-form) env k)
    (evaluate-progn/cc (body symbol-macrolet) env k))
  
  ;;;; TAGBODY/GO
  
  