anchor.diff:                (lambda-export-gather fi x)
                 (lambda-export-transform fi x))
   		  `#'(,@(make-lambda-funinfo-if-missing x
  -				  (make-funinfo :env (lambda-args x)
  -								:args (lambda-args x)
  +				  (make-funinfo :args (lambda-args x)
   								:parent fi))
   			  ,(lambda-args x)
   			  ,@(lambda-body x)))
  
positive.code: 	  ; temporarily to make stack-places; so the stack-places can be
  	  ; reused by the next lambda-call on the same level.
        ;(with-funinfo-env-temporary fi args
        (dolist (i a)
  		(unless (funinfo-env-pos fi i)
  		  (funinfo-env-add fi i)))
        (make-inline-body
  		  (vars-to-stackplaces fi a)
        	  v
  		  (lambda-expand-gather-or-transform fi body export-lambdas gather)))));)
  
  ;;; Export
  
  (defun make-var-declarations (fi)
    (vars-to-stackplaces fi
      (mapcan (fn (unless (and (not (eq (funinfo-lexical fi)
  									  _))
  						 	 (or (funinfo-arg? fi _)
  						    	 (funinfo-lexical-pos fi _)))
  				  `((%var ,_))))
  	        (funinfo-env fi))))
  
  
negative.code: 				    `(%setq ,stack-place ,init-value))
  			   stack-places values)
       ,@body))
  
  (defun lambda-call-embed-find-doubles (fi x)
    (when x
      (if (funinfo-in-args-or-env? fi x.)
  	    (cons x.
  			  (lambda-call-embed-find-doubles fi .x))
  	    (lambda-call-embed-find-doubles fi .x))))
  
  (defun lambda-call-embed-rename-doubles (doubles)
    (when doubles
  	(cons (cons doubles. (gensym))
  	  	  (lambda-call-embed-rename-doubles .doubles))))
  
  (defun assoc-replace (x alst)
    (or (assoc-value x alst)
  	   x))
  
  (defun assoc-replace-many (x alst)
    (when x
  	 (cons (assoc-replace x. alst)
  		   (assoc-replace-many .x alst))))
  
  (defun funinfo-rename (fi x)
    (assoc-replace x (funinfo-renamed-vars fi)))
  
  (defun funinfo-rename-many (fi x)
    (assoc-replace-many x (funinfo-renamed-vars fi)))
  
  (defun lambda-call-embed (fi lambda-call export-lambdas gather)
    (with-lambda-call (args vals body lambda-call)
  