anchor.diff:      (maybe-add-environment-variable binding))
     (mapc #'compute-environment-layout (cddr form)))
   
  +(defun compute-free-variable-sets (lambda)
  +  (let ((*free-variables* (make-hash-table)))
  +    (compute-free-variable-sets-1 lambda)
  +    *free-variables*))
  +
  +(defun compute-free-variable-sets-1 (form)
  +  (flet ((process-progn (forms)
  +           (reduce 'union (mapcar #'compute-free-variable-sets-1 forms) :initial-value '())))
  +    (etypecase form
  +      (cons (case (first form)
  +              ((block)
  +               (remove (second form) (process-progn (cddr form))))
  +              ((function)
  +               '())
  +              ((go)
  +               (compute-free-variable-sets-1 (third form)))
  +              ((if)
  +               (process-progn (cdr form)))
  +              ((let)
  +               (let ((vars (union (process-progn (mapcar #'second (second form)))
  +                                  (process-progn (cddr form))))
  +                     (defs (mapcar #'first (second form))))
  +                 (set-difference vars defs)))
  +              ((multiple-value-bind)
  +               (let ((vars (process-progn (cddr form)))
  +                     (defs (second form)))
  +                 (set-difference vars defs)))
  +              ((multiple-value-call)
  +               (process-progn (cdr form)))
  +              ((multiple-value-prog1)
  +               (process-progn (cdr form)))
  +              ((progn)
  +               (process-progn (cdr form)))
  +              ((quote)
  +               '())
  +              ((return-from)
  +               (union (compute-free-variable-sets-1 (third form))
  +                      (compute-free-variable-sets-1 (fourth form))))
  +              ((setq)
  +               (process-progn (cdr form)))
  +              ((tagbody)
  +               (remove (second form) (process-progn (remove-if #'go-tag-p (cddr form)))))
  +              ((the)
  +               (compute-free-variable-sets-1 (third form)))
  +              ((unwind-protect)
  +               (process-progn (cdr form)))
  +              (t (process-progn (cdr form)))))
  +      (lexical-variable (list form))
  +      (lambda-information
  +       (let* ((initforms (append (mapcar #'second (lambda-information-optional-args form))
  +                                 (mapcar #'second (lambda-information-key-args form))))
  +              (defs (append (lambda-information-required-args form)
  +                            (mapcar #'first (lambda-information-optional-args form))
  +                            (mapcar #'third (lambda-information-optional-args form))
  +                            (mapcar #'second (mapcar #'first (lambda-information-key-args form)))
  +                            (mapcar #'third (lambda-information-key-args form))
  +                            (when (lambda-information-rest-arg form)
  +                              (list (lambda-information-rest-arg form)))
  +                            (when (lambda-information-environment-arg form)
  +                              (list (lambda-information-environment-arg form)))))
  +              (vars (set-difference (union (process-progn initforms)
  +                                           (process-progn (lambda-information-body form)))
  +                                    defs)))
  +         (setf (gethash form *free-variables*) vars)
  +         vars)))))
  +
   (defun lower-env-form (form)
     (etypecase form
       (cons (case (first form)
  
positive.code: 	    (t (le-form*-cdr form))))
      (lexical-variable (le-variable form))
      (lambda-information
       (cond ((not *environment-chain*)
              (le-lambda form))
             ((getf (lambda-information-plist form) 'declared-dynamic-extent)
              `(sys.c::make-dx-closure
                ,(le-lambda form)
  
negative.code: (defvar *active-environment-vector*)
  (defvar *allow-dx-environment*)
  (defvar *environment-allocation-mode* nil)
  (defvar *free-variables*)
  
  (defun lower-environment (lambda)
    (let ((*environment-layout* (make-hash-table))
          (*environment-layout-dx* (make-hash-table)))
      (compute-environment-layout lambda)
      (let ((*free-variables* (compute-free-variable-sets lambda))
            (*environment* '()))
        (lower-env-form lambda))))
  
  (defun quoted-form-p (form)
  