anchor.diff:    (let last-place nil
       (mapcan [with (name names.
                      args (? last-place
  -                         '(~%contret))
  +                           '(~%contret))
                      body `(,@(awhen last-place
                                 (clr last-place)
                                 `((%setq ,! ~%contret)))
                             ,@(butlast _)
                             ,@(alet (car (last _))
                                 (?
  -                                (& (%setq-funcall? !)
  -                                   (| (%slot-value? (car (%setq-value !)))
  -                                      (transpiler-cps-function? *transpiler* (car (%setq-value !)))))
  -                                                   (progn
  -                                                     (= last-place (%setq-place !))
  -                                                     `((%setq nil (cps-funcall ,(car (%setq-value !))
  -                                                                               ,.names.
  -                                                                               ,@(cdr (%setq-value !))))))
  -                                (%%go? !)          `((%setq nil (,(assoc-value .!. tag-names))))
  -                                (%%go-nil? !)      `((%%call-nil ,..!. ,(assoc-value .!. tag-names) ,.names.))
  -                                (+ (list !)
  -                                   (? .names
  -                                      `((%setq nil (,.names.)))
  -                                      `((%setq nil (~%cont ~%ret)))))))))
  +                                (cps-call? !)  (progn
  +                                                 (= last-place (%setq-place !))
  +                                                 `((%setq nil (cps-funcall ,(car (%setq-value !))
  +                                                                           ,.names.
  +                                                                           ,@(cdr (%setq-value !))))))
  +                                (%%go? !)      `((%setq nil (,(assoc-value .!. tag-names))))
  +                                (%%go-nil? !)  `((%%call-nil ,..!. ,(assoc-value .!. tag-names) ,.names.))
  +                                (+ (& ! (list !))
  +                                   (?
  +                                     .names                `((%setq nil (,.names.)))
  +                                     (not *cps-toplevel?*) `((%setq nil (~%cont ~%ret)))))))))
                 (alet (create-funinfo :name   name
                                       :args   args
                                       :body   body
  
positive.code:      x))
  
  (defun cps-fun (x)
    (with-temporary *funinfo* (get-lambda-funinfo x)
      (copy-lambda x :body (cps (lambda-body x)))))
  
  (defun cps-subfuns (x)
    (when x
      (cons (? (named-lambda? x.)
               (cps-fun x.)
               x.)
            (cps .x))))
  
  (defun cps (x)
    (alet (cps-split-body x)
      (+ (cps-make-funs (carlist !) (cps-tag-names !) (filter (compose #'cps-subfuns
                                                                       #'cps-body-without-tag)
                                                              (cdrlist !)))
         `((%setq nil (,!..))))))
  
negative.code: ;;;;; tré – Copyright (c) 2013 Sven Michael Klose <pixel@copei.de>
  
  (defvar *cps-toplevel?* nil)
  
  (defun cps-call? (x)
    (& (%setq-funcall? x)
       (transpiler-cps-function? *transpiler* (car (%setq-value x)))))
  
  (defun cps-splitpoint? (x)
    (| (number? x)
       (cps-call? x)
       (%%go? x)
       (%%go-nil? x)))
  
  (defvar *cps-function-counter* 0)
  
  (defun cps-split-body (x)
    (filter [cons ($ '~CPS (++! *cps-function-counter*)) _]
            (split-if #'cps-splitpoint? x :include? t)))
  
  (defun cps-tag-names (x)
  