anchor.diff:  				   '%var
   				   '%no-expex))))
   
  -;; Check if an expression is inline.
  -;;
  -;; These expressions are not moved out, but their arguments are expanded.
  -(defun expex-inline? (ex x)
  -  (and (consp x)
  -       (in? x. '%slot-value)))
  -
   ;; Check if an expression has a return value.
   (defun expex-returnable? (ex x)
     (not (or (vm-jump? x)
   		   (and (consp x)
   				(eq '%var x.)))))
  +
  +(defun expex-expandable-args? (ex fun argdef)
  +  (or (eq '%%no-argexp argdef)
  +	  (funcall (expex-plain-arg-fun? ex) fun)))
  +
  +(defun expex-argexpand-do (ex fun args)
  +  (funcall (expex-function-collector ex) fun args)
  +  (let argdef (funcall (expex-function-arguments ex) fun)
  +    (if (expex-expandable-args? ex fun argdef)
  +	    args
  +        (argument-expand-compiled-values fun
  +										 argdef
  +								         args))))
  +
  +(defun expex-argexpand (ex fun args)
  +  (if (and (atom fun)
  +		   (funcall (expex-function? ex) fun))
  +	  (expex-argexpand-do ex fun args)
  +	  args))
  +
  +;; Check if an expression is inline.
  +;;
  +;; These expressions are not moved out, but their arguments are expanded.
  +(defun expex-inline? (ex x)
  +  (and (consp x)
  +       (in? x. '%slot-value)))
   
   (defun expex-assignment-inline (ex x)
     (with ((p a) (expex-args ex .x))
  
positive.code: 	(if (expex-able? ex x.)
          (with ((head tail) (expex-expr ex x.))
            (append head tail (expex-list ex .x)))
  		(cons x. (expex-list ex .x)))))
  
  (defun expex-make-return-value (ex e s)
    (with (b  (butlast e)
  
negative.code:       (values nil (list x))
      (vm-scope? x)
  	  (values nil (expex-body ex (vm-scope-body x)))
      (%setq? x)
        (expex-expr-setq ex x)
      (expex-std-expr ex x)))
  
  ;; Entry point.
  