anchor.diff:  (defvar *free-variables*)
   (defvar *environment*)
   (defvar *lambda-parents*)
  +(defvar *current-closure-set*)
   
   (defun lower-environment (lambda)
     (let ((*environment-layout* (make-hash-table))
           (*environment-layout-dx* (make-hash-table))
           (*allow-dx-environment* 't)
           (*current-lambda* nil)
  -        (*lambda-parents* (make-hash-table)))
  +        (*lambda-parents* (make-hash-table))
  +        (*free-variables* (compute-free-variable-sets lambda))
  +        (*current-closure-set* '()))
       (compute-environment-layout lambda)
  -    (let ((*free-variables* (compute-free-variable-sets lambda))
  -          (*environment* '()))
  +    (let ((*environment* '()))
         (lower-env-form lambda))))
   
   (defun quoted-form-p (form)
  
positive.code:              (not (localp variable)))
      (push variable (gethash *active-environment-vector* *environment-layout*))))
  
  (defun lambda-tree-is-dynamic-extent-p (lambda end)
    (cond ((eql lambda end)
           t)
          (t
           (and (or (eql (getf (lambda-information-plist lambda) 'extent) :dynamic)
                    (getf (lambda-information-plist lambda) 'declared-dynamic-extent))
                (lambda-tree-is-dynamic-extent-p (gethash lambda *lambda-parents*) end)))))
  
  (defun finalize-environment-layout (env)
    ;; Inner environments must be DX, and every variable in this environment
    ;; must only be accessed by DX lambdas.
    (when (and *allow-dx-environment*
               (not *perform-tce*)
               (every (lambda (var)
  
negative.code:     (setf (gethash lambda *lambda-parents*) *current-lambda*)
      (let ((*active-environment-vector* lambda)
            (*allow-dx-environment* t)
            (*current-lambda* lambda)
            (*current-closure-set* '()))
        (assert (null (lambda-information-environment-arg lambda)))
        (check-simple-lambda-parameters lambda)
        (dolist (arg (lambda-information-required-args lambda))
  