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:           (& (number? !)
               (enqueue q (. ! (| (caadr i)
                                  '~%cont))))))))
  
  ;(defun cps-tag-names (x)
  ;  (mapcan [!? (car (last ._))
  ;              (& (number? !)
  ;                 (list (. ! _.)))]
  ;          x))
  
  (defun cps-make-call (x continuer)
    (with (val               (%=-value x)
  
negative.code:                            ,@(butlast _)
                             ,@(alet (car (last _))
                                 (?
                                   (call-to-non-cps-from-expander? !) (call-to-non-cps-from-expander !)
                                   (cps-call? !)        (make-call !)
                                   (cps-methodcall? !)  (make-methodcall !)
                                   (%%go? !)            (make-go !)
                                   (%%go-cond? !)       (make-cond !)
                                   (+ (& (not (number? !))
                                         (list !))
                                      (?
                                        .names                `((%= nil (,.names.)))
  