anchor.diff:            (& (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)
  
positive.code:                            ,@(butlast _)
                             ,@(alet (car (last _))
                                 (?
                                   (cps-call? !)        (make-call !)
                                   (cps-methodcall? !)  (make-methodcall !)
                                   (%%go? !)            (make-go !)
                                   (%%go-cond? !)       (make-cond !)
                                   (+ (& !
                                         (not (number? !))
                                         (list !))
                                      (?
                                        .names                `((%= nil (,.names.)))
  
negative.code: 
  (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)
    (& (%=-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)
  