anchor.diff:      (values (apply #'append pre)
   			main)))
   
  +(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)
  -  (if (funcall (expex-plain-arg-fun? ex) fun)
  -	  args
  -      (argument-expand-compiled-values fun
  -								       (funcall (expex-function-arguments 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)
  
positive.code: ;; Recurses into LAMBDA-expressions and VM-SCOPEs.
  ;; Removes VM-SCOPEs.
  (defun expex-expr (ex x)
    (if (lambda? x)
        (values nil (list `#'(lambda ,(lambda-args x)
  						     ,@(expex-body ex (lambda-body x)))))
        (if (not (expex-able? ex x))
  	      (values nil (list x))
    	      (if (vm-scope? x)
  	          (values nil (expex-body ex (vm-scope-body x)))
  	          (expex-std-expr ex x)))))
  
  ;; Entry point.
  ;;
  
negative.code: (defun expex-assignment (ex x)
    (if
  	(expex-inline? ex x)
  	  (expex-assignment-inline ex x)
  	(not (expex-able? ex x))
        (cons nil x)
      (vm-scope? x)
  	  (expex-assignment-vm-scope ex x)
  	(expex-assignment-std ex x)))
  
  ;; Move subexpressions out of a parent.
  ;;
  