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:     ()
    (kontinue k nil))
  
  (defmethod evaluate/cps ((tagbody tagbody-form) env k)
    (evaluate/cps-progn (body tagbody) (register env :tag tagbody k) `(tagbody-k ,k)))
  
  (defmethod evaluate/cps ((go-tag go-tag-form) env k)
    (declare (ignore go-tag env))
    (kontinue k nil))
  
  (defmethod evaluate/cps ((go go-form) env k)
    (declare (ignore k))
    (evaluate/cps-progn (target-progn go) env (lookup env :tag (enclosing-tagbody go) :error-p t)))
  
  ;;;; THE
  
  (defmethod evaluate/cps ((the the-form) env k)
    (evaluate/cps (value the) env k))
  
  ;;;; DEFUN/CC and DEFMETHOD/CC
  
  
negative.code: 
  (defun evaluate-m-v-c (remaining-arguments evaluated-arguments env k)
    (if remaining-arguments
        (evaluate/cc (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
            (closure/cc (apply-lambda/cc function evaluated-arguments k))
            (function (apply #'kontinue k (multiple-value-list
                                           (multiple-value-call function (values-list arguments)))))))))
  
  (defmethod evaluate/cc ((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/cc ((progn progn-form) env k)
    (evaluate-progn/cc (body progn) env k))
  
  (defk k-for-evaluate-progn/cc (rest-of-body env k)
      ()
    (evaluate-progn/cc rest-of-body env k))
  
  (defun evaluate-progn/cc (body env k)
    (cond
      ((cdr body)
        (evaluate/cc (first body) env
                      `(k-for-evaluate-progn/cc ,(cdr body) ,env ,k)))
      (body
       (evaluate/cc (first body) env k))
      (t
       (kontinue k nil))))
  
  