anchor.diff:  ;;
   ;; Recurses into LAMBDA-expressions and VM-SCOPEs.
   ;; VM-SCOPES are removed.
  -(defun expex-expr (x)
  +(defun expex-expr (ex x)
     (if (is-lambda? x)
         (values nil (list `#'(lambda ,(lambda-args x)
  -						     ,@(expex-body (lambda-body x)))))
  -      (if (not (expex-able? 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 (cdr x)))
  -	          (expex-std-expr x)))))
  +	          (values nil (expex-body ex (cdr x)))
  +	          (expex-std-expr ex x)))))
   
   ;; Entry point.
   ;;
   ;; Simply concatenates the results of all expression
   ;; expansions in a body.
  -(defun expex-list (x)
  +(defun expex-list (ex x)
     (when x
  -     (with ((head tail) (expex-expr (car x)))
  -       (append head tail (expex-list (cdr x))))))
  +     (with ((head tail) (expex-expr ex (car x)))
  +       (append head tail (expex-list ex (cdr x))))))
   
   ;; Expand VM-SCOPE body and have the return value of the
   ;; last expression assigned to a gensym which will replace
   ;; it in the parent expression.
  -(defun expex-body (x &optional (s '~%ret))
  -  (with (e (expex-list x))
  -   	(expex-make-return-value e s)))
  +(defun expex-body (ex x &optional (s '~%ret))
  +  (with (e (expex-list ex x))
  +   	(expex-make-return-value ex e s)))
   
  -(define-expander 'expex)
  -(define-expander-macro 'expex %setq (plc val)
  -  (if (vm-jump? val)
  -	  val
  -	  `(%setq ,plc ,val)))
  -
  -(defun expression-expand (x)
  -  ;(expander-expand 'expex (expex-list x)))
  -  (expex-body x))
  +(defun expression-expand (ex x)
  +  (expex-body ex x))
  
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: ;;
  ;; Returns the head of moved expressions and a new parent with
  ;; replaced arguments.
  (defun expex-args (ex x)
    (with ((pre main) (assoc-splice (mapcar #'((x)
  											   (expex-assignment ex x))
  										  x)))
      (values (apply #'append pre)
  			main)))
  
  