anchor.diff:  				    `(%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)
  
positive.code: 		 ,(funinfo-lexical-pos (funinfo-parent fi) var)))
  
  (defun make-lexical-1 (fi var)
    (if (funinfo-env-pos (funinfo-parent fi) var)
  	  (make-lexical-place-expr fi var)
  	  (make-lexical-1 (funinfo-parent fi) var)))
  
  (defun make-lexical-0 (fi x)
    (funinfo-setup-lexical-links (funinfo-parent fi) fi x)
    (let ret (make-lexical-1  fi x)
  	`(%vec ,(make-lexical fi .ret.)
  		   ,..ret.)))
  
  
negative.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
  ;      (with-temporary (funinfo-renamed-vars fi)
  ;      				  (append (lambda-call-embed-rename-doubles
  ;          				  		  (lambda-call-embed-find-doubles fi a))
  ;							  (funinfo-renamed-vars fi))
  	    (funinfo-env-add-many fi a) ;(funinfo-rename-many fi a))
          (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 (or (transpiler-stack-locals? *current-transpiler*)
   							(and (not (eq _ (funinfo-lexical fi)))
  								 (funinfo-lexical-pos fi _)))
  				  `((%var ,_))))
  	        (funinfo-env fi))))
  
  