anchor.diff:       (butlast x)
        x))
   
  +(defun cps-body-0 (x)
  +  (mapcan [? (named-lambda? _)
  +             (cps-fun _)
  +             (list _)]
  +          x))
  +
   (defun cps-body (x)
     (!? (cps-split-body x)
         (+ (cps-make-funs :names     (carlist !)
                           :tag-names (cps-tag-names !)
  -                        :bodies    (filter #'cps-subfuns (cdrlist !)))
  +                        :bodies    (filter #'cps-body-0 (cdrlist !)))
            `((%= nil (,!..))))
         x))
   
   (defun cps-fun (x)
  -  (with-temporaries (*funinfo*        (get-lambda-funinfo x)
  -                     *cps-toplevel?*  nil)
  +  (with-temporary *funinfo* (get-lambda-funinfo x)
       (with-lambda name args body x
         (?
  +        (eq 'apply (funinfo-name *funinfo*))
  +          (list (copy-lambda x :args (. '~%cont args)))
           (transpiler-native-cps-function? *transpiler* (funinfo-name *funinfo*))
  -          (list (copy-lambda x :args (. '~%cont args)))
  +          (list (copy-lambda x :args (. '~%cont args) :body (cps-passthrough body)))
           (funinfo-cps? *funinfo*)
  -          (list (copy-lambda x :args (. '~%cont args) :body (cps-body body))
  -                `(%= (%slot-value ,name _cps-transformed?) t))
  -        (list (copy-lambda x))))))
  +          (with-temporary *cps-toplevel?* nil
  +            (list (copy-lambda x :args (. '~%cont args) :body (cps-body body))
  +                  `(%= (%slot-value ,name _cps-transformed?) t)))
  +        (list (copy-lambda x :body (cps-passthrough body)))))))
   
   (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-passthrough (x)
  +  (with-temporary *cps-toplevel?* t
  +    (mapcan [?
  +              (native-cps-funcall? _)  (let v (%=-value _)
  +                                         `((%= ,(%=-place _) (,v. ,(cps-return-value _) ,@.v))))
  +              (cps-call? _)            (cps-make-call _ (cps-return-value _))
  +              (cps-methodcall? _)      (cps-make-methodcall _ (cps-return-value _))
  +              (named-lambda? _)        (cps-fun _)
  +              (list _)]
  +            x)))
   
   (defun cps (x)
  -  (with-temporary *cps-toplevel?* t
  -    (cps-subfuns x)))
  +  (cps-passthrough 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:           (& (number? !)
               (enqueue q (. ! (| (caadr i)
                                  '~%cont))))))))
  
  (defun cps-make-call (x continuer)
    (with (val               (%=-value x)
  