anchor.diff:  
   (defun expex-move-atom (x)
     (let s (expex-funinfo-var-add)
  -    (cons (expex-make-%= s x) s)))
  +    (. (expex-make-%= s x) s)))
   
   (defun expex-move-inline (x)
     (with ((p a) (expex-move-args x))
  -	(cons p a)))
  +	(. p a)))
   
   (defun expex-move-%%block (x)
     (!? (%%block-body x)
         (let s (expex-funinfo-var-add)
  -        (cons (expex-body ! s) s))
  -	  (cons nil nil)))
  +        (. (expex-body ! s) s))
  +	  (. nil nil)))
   
   (defun expex-move-std (x)
     (with (s                (expex-funinfo-var-add)
            (moved new-expr) (expex-expr x))
  -    (cons (+ moved
  -             (? (has-return-value? new-expr.)
  -                (expex-make-%= s new-expr.)
  -                new-expr))
  -          s)))
  +    (. (+ moved
  +          (? (has-return-value? new-expr.)
  +             (expex-make-%= s new-expr.)
  +             new-expr))
  +       s)))
   
   (defun expex-move (x)
     (?
  -	(not (expex-able? x))                (cons nil x)
  +	(not (expex-able? x))                (. nil x)
       (atom x)                             (expex-move-atom x)
   	(funcall (expex-inline? *expex*) x)  (expex-move-inline x)
       (%%block? x)                         (expex-move-%%block x)
  
positive.code: ;;;; UTILS
  
  (defun expex-make-%= (plc val)
    (+ (? (%=? val)
          (expex-guest-filter-setter val))
       (expex-guest-filter-setter `(%= ,plc ,(? (%=? val)
  
negative.code: ;;;; BODY EXPANSION
  
  (defun expex-force-%= (x)
    (| (& (metacode-expression-only x)
          (list x))
       (expex-make-%= '~%ret x)))
  
  (defun expex-make-return-value (s x)
  