anchor.diff:  				   x))
   		  (cdrlist (argument-expand (function-arguments (symbol-function fun)) args t))))
   
  -(defun expex-argexpand (fun args)
  +(defun expex-argexpand (ex fun args)
     (if (and (atom fun)
   		   (functionp (symbol-function fun)))
  -	  (expex-argexpand-do fun args)
  +	  (expex-argexpand-do ex fun args)
   	  args))
   
   ;; Expands standard expression.
   ;;
   ;; The arguments are replaced by gensyms.
  -(defun expex-std-expr (x)
  -  (with (argexp (expex-argexpand (car x) (cdr x))
  -		 (pre newargs) (expex-args argexp))
  +(defun expex-std-expr (ex x)
  +  (with (argexp (expex-argexpand ex (car x) (cdr x))
  +		 (pre newargs) (expex-args ex argexp))
       (values pre
   			(list (cons (car x) newargs)))))
   
  
positive.code: 	`(cons ,(car args)
  		   ,(expex-argexpand-rest (cdr args)))))
  
  (defun expex-argexpand-do (fun args)
    (mapcar #'((x)
  			   (if (and (consp x)
  						(eq '&rest (car x)))
  
negative.code: ;; Check if an expression is expandable.
  ;;
  ;; Declines atoms and expressions with meta-forms.
  (defun expex-able? (ex x)
    (not (or (atom x)
             (in? (car x) 'get-slot '%funref 'vm-go 'vm-go-nil '%stack '%quote '%transpiler-string '%no-expex))))
  
  ;; Check if an expression has a return value.
  (defun expex-returnable? (ex x)
    (not (vm-jump? x)))
  
  (defun expex-make-return-value (ex e s)
    (with (b (butlast e)
  		 l (last e)
  		 la (car l))
     	(if (expex-returnable? ex la)
  		(append b (if (%setq? la)
  					  (if (%setqret? la)
  				          `((%setq ~%ret ,(third la)))
  