anchor.diff:  
   (defvar *cps-toplevel?* nil)
   
  +(defun call-from-argument-expander? (x)
  +  (& (%%native? x)
  +     (alet (real-function-name .x.)
  +       (| (transpiler-native-cps-function? *transpiler* !)
  +          (not (transpiler-cps-exception? *transpiler* (real-function-name !)))))))
  +
  +(defun call-to-non-cps-from-expander? (x)
  +  (& (%=-funcall? x)
  +     (alet (car (%=-value x))
  +       (& (%%native? !)
  +          (transpiler-cps-exception? *transpiler* (real-function-name .!.))))))
  +
  +(defun call-to-non-cps-from-expander (x)
  +  (with-gensym g
  +    (funinfo-var-add *funinfo* g)
  +    `((%= ,g ,(%=-value x))
  +      (%= nil (~%cont ,g)))))
  +
  +(defun call-of-global-cps-function? (name)
  +  (& (not (transpiler-cps-exception? *transpiler* name))
  +     (!? (get-funinfo name)
  +         (funinfo-cps? !))))
  +
  +(defun call-of-local-function? (name)
  +  (funinfo-find *funinfo* name))
  +
   (defun cps-call? (x)
  -  (with (call-from-argument-expander?
  -             [& (%%native? _)
  -                (not (transpiler-cps-exception? *transpiler* (real-function-name ._.)))]
  -         call-of-local-function?
  -             [funinfo-find *funinfo* _]
  -         call-of-global-cps-function?
  -             [& (not (transpiler-cps-exception? *transpiler* _))
  -                (!? (get-funinfo _)
  -                    (funinfo-cps? !))])
  -    (& (%=-funcall? x)
  -       (alet (car (%=-value x))
  -         (| (transpiler-native-cps-function? *transpiler* !)
  -            (call-from-argument-expander? !)
  -            (call-of-local-function? !)
  -            (call-of-global-cps-function? !))))))
  +  (& (%=-funcall? x)
  +     (alet (car (%=-value x))
  +       (| (transpiler-native-cps-function? *transpiler* !)
  +          (call-from-argument-expander? !)
  +          (call-of-local-function? !)
  +          (call-of-global-cps-function? !)))))
   
   (defun cps-methodcall? (x)
     (& (%=-funcall? x)
        (%slot-value? (car (%=-value x)))))
  +
  +(defun native-cps-funcall? (x)
  +  (& (%=-funcall? x)
  +     (transpiler-native-cps-function? *transpiler* (alet (car (%=-value x))
  +                                                     (? (%%native? !)
  +                                                        (real-function-name .!.)
  +                                                        !)))))
   
   (defun cps-splitpoint? (x)
     (| (number? x)
  
positive.code:      (butlast x)
       x))
  
  (defun cps-body (x)
    (!? (cps-split-body x)
        (+ (cps-make-funs :names     (carlist !)
                          :tag-names (cps-tag-names !)
                          :bodies    (filter #'cps-subfuns (cdrlist !)))
           `((%= nil (,!..))))
        x))
  
  (defun cps-fun (x)
    (with-temporaries (*funinfo*        (get-lambda-funinfo x)
                       *cps-toplevel?*  nil)
      (with-lambda name args body x
        (?
          (transpiler-native-cps-function? *transpiler* (funinfo-name *funinfo*))
            (list (copy-lambda x :args (. '~%cont args)))
          (funinfo-cps? *funinfo*)
            (list (copy-lambda x :args (. '~%cont args) :body (cps-body body))
                  `(%= (%slot-value ,name _cps-transformed?) t))
          (list (copy-lambda x))))))
  
  (defun cps-return-value (x)
    (!? (%=-place x)
        `(cps-toplevel-return-value ,!)
        'cps-identity))
  
  (defun cps-subfuns (x)
    (when x
      (+ (?
           (named-lambda? x.)        (cps-fun x.)
           (& *cps-toplevel?*
              (cps-call? x.))        (cps-make-call x. (cps-return-value x))
           (& *cps-toplevel?*
              (cps-methodcall? x.))  (cps-make-methodcall x. (cps-return-value x))
           (list x.))
         (cps-subfuns .x))))
  
  (defun cps (x)
    (with-temporary *cps-toplevel?* t
      (cps-subfuns x)))
  
negative.code:           (& (number? !)
               (enqueue q (. ! (| (caadr i)
                                  '~%cont))))))))
  
  (defun cps-make-call (x continuer)
    (with (val               (%=-value x)
  