anchor.diff:  					(if (eq s (second last.))
   				        (expex-guest-filter-setter ex last.)
   						(expex-make-setq-copy ex last s))
  -				    (expex-guest-filter-setter ex `(%setq ,s ,@(or last '(nil))))))
  +				    (expex-make-%setq ex s last.)))
   		x)))
   
  +(defun expex-atom-to-identity-expr (x)
  +  (? (and (atom x)
  +	      (not (number? x)))
  +	 `(identity ,x)
  +	 x))
  +
   (defun expex-save-atoms (x)
  -  (mapcar (fn if (and (atom _)
  -					  (not (number? _)))
  -				 `(identity ,_)
  -				 _)
  -		  (or x (list nil))))
  +  (mapcar #'expex-atom-to-identity-expr x))
   
   (defun expex-list (ex x)
  -  (when x
  -    (with ((moved new-expr) (expex-expr ex x.))
  -      (append moved
  -			  (mapcan (fn expex-force-%setq ex _) new-expr)
  -			  (expex-list ex .x)))))
  +  (mapcan (fn with ((moved new-expr) (expex-expr ex _))
  +               (append moved (mapcan (fn expex-force-%setq ex _) new-expr)))
  +          x))
   
   (defun expex-body (ex x &optional (s '~%ret))
     (expex-make-return-value ex s (expex-list ex (expex-save-atoms (list-without-noargs-tag x)))))
  
positive.code:       (when (lambda-expression-needing-cps? x)
          (transpiler-add-cps-function *current-transpiler* s))
        (cons (append moved
  		    		(if (expex-returnable? ex new-expr.)
  		        		(expex-guest-filter-setter ex `(%setq ,s ,@new-expr))
  			    		new-expr))
    	        s)))
  
  (defun expex-move-arg-atom (ex x)
    (let s (expex-funinfo-env-add)
      (cons (expex-guest-filter-setter ex `((%setq ,s ,x)))
            s)))
  
  (defun expex-move-arg (ex x)
    (?
  
negative.code:   (mapcar (fn (funcall (expex-argument-filter ex) _)) x))
  
  ;;;; UTILS
  
  (defun expex-make-%setq (ex plc val)
    (expex-guest-filter-setter ex `(%setq ,plc ,(peel-identity val))))
  
  (defun expex-funinfo-env-add ()
    (let s (expex-sym)
  