anchor.diff:  
   (defun expex-move (x)
     (pcase x
  -	unexpex-able?     (. nil x)
  -	expex-inlinable?  (expex-move-inline x)
  +    unexpex-able?     (. nil x)
  +    expex-inlinable?  (expex-move-inline x)
       %%block?          (expex-move-%%block x)
  -	(expex-move-std x)))
  +    (expex-move-std x)))
   
   (defun expex-move-args (x)
  -  (with (filtered          (expex-guest-filter-arguments x)
  -         (moved new-expr)  (assoc-splice (@ #'expex-move filtered)))
  +  (with ((moved new-expr) (assoc-splice (@ #'expex-move (expex-guest-filter-arguments x))))
       (values (apply #'append moved) new-expr)))
   
   
  
positive.code:                                    (eq s (%=-place l)))
           make-return-value     #'(()
                                     `(,l
                                       ,@(expex-make-%= s (%=-place l)))))
      (? (has-return-value? l)
         (append (butlast x)
                 (? (%=? l)
                    (? (wanted-return-value?)
                       (expex-guest-filter-setter l)
                       (make-return-value))
                    (expex-make-%= s l)))
         x)))
  
  (defun expex-body (x &optional (s '~%ret))
    (with (ensure-%=  [| (& (| (metacode-expression? _)
                               (%%comment? _))
                            (list _))
                         (expex-make-%= '~%ret _)])
      (expex-make-return-value s 
          (mapcan [with ((moved new-expr) (expex-expr _))
                   (append moved (mapcan #'ensure-%= new-expr))]
  
negative.code: 
  ;;;; UTILS
  
  (defun make-%= (p v)
    (when (atom v)
      (= v (funcall (expex-argument-filter *expex*) v)))
    (expex-guest-filter-setter `(%= ,p ,(? (%=? v)
                                           (%=-place v)
                                           v))))
  
  (defun expex-add-var ()
    (funinfo-var-add *funinfo* (expex-sym)))
  