anchor.diff:  (defun expex-move-std (x)
     (with (s                (expex-funinfo-var-add)
            (moved new-expr) (expex-expr x))
  -    (. (+ moved
  -          (? (has-return-value? new-expr.)
  -             (expex-make-%= s new-expr.)
  -             new-expr))
  +    (. (append moved
  +               (? (has-return-value? new-expr.)
  +                  (expex-make-%= s new-expr.)
  +                  new-expr))
          s)))
   
   (defun expex-inlinable? (x)
  
positive.code:      (expex-make-%= '~%ret x)))
  
  (defun expex-make-return-value (s x)
    (with (last (car (last x))
           wanted-return-value? #'(()
                                     (eq s (%=-place last)))
           make-return-value    #'(()
                                     `(,last
                                       ,@(expex-make-%= s (%=-place last)))))
      (? (has-return-value? last)
         (+ (butlast x)
            (? (%=? last)
               (? (wanted-return-value?)
                  (expex-guest-filter-setter last)
                  (make-return-value))
               (expex-make-%= s last)))
         x)))
  
  (defun expex-body (x &optional (s '~%ret))
    (expex-make-return-value s (mapcan [with ((moved new-expr) (expex-expr _))
                                         (+ moved (mapcan #'expex-force-%= new-expr))]
                                       (distinguish-vars-from-tags (list-without-noargs-tag x)))))
  
  
  
negative.code: (defun expex-make-%= (plc val)
    (when (atom val)
      (= val (funcall (expex-argument-filter *expex*) val)))
    (append (? (%=? val)
               (expex-guest-filter-setter val))
            (expex-guest-filter-setter `(%= ,plc ,(? (%=? val)
                                                     (%=-place val)
                                                     val)))))
  
  (defun expex-funinfo-var-add ()
    (aprog1 (expex-sym)
  