anchor.diff:      (compute-environment-layout `(progn ,@(lambda-information-body lambda)))))
   
   (defun compute-tagbody-environment-layout (form)
  -  "TAGBODY defines a single variable in the enclosing environment and opens a new contour."
  +  "TAGBODY defines a single variable in the enclosing environment and each group
  +of statements opens a new contour."
     (maybe-add-environment-variable (second form))
  -  (let ((*active-environment-vector* form))
  -    (mapc #'compute-environment-layout (remove-if #'go-tag-p (cddr form)))))
  +  (let ((last-tag (second form)))
  +    (dolist (stmt (cddr form))
  +      (cond ((go-tag-p stmt)
  +             (setf last-tag stmt))
  +            (t (let ((*active-environment-vector* last-tag))
  +                 (compute-environment-layout stmt)))))))
   
   (defun compute-block-environment-layout (form)
     "BLOCK defines one variable."
  
positive.code:   form)
  
  (defun le-tagbody (form)
    (let ((local-env (gethash form *environment-layout*))
          (new-env (make-lexical-variable :name (gensym "Environment")
                                          :definition-point *current-lambda*)))
      (labels ((frob-outer ()
               `(tagbody ,(second form)
                   ;; Save the tagbody info.
  
negative.code:                                    (second form)
                                     env-var
                                     `',env-offset))))
                   ,@(let ((info (assoc (second form) new-envs)))
                       (when info
                         (list `(setq ,(second info) (sys.int::make-simple-vector ',(1+ (length (third info))))))))
                   ,@(frob-inner (second form))))
               (frob-inner (current-env)
                 (loop for stmt in (cddr form)
                    append (cond ((go-tag-p stmt)
                                  (setf current-env stmt)
                                  (let ((info (assoc current-env new-envs)))
                                    (append (list stmt)
                                            (when info
                                              (list `(setq ,(second info) (sys.int::make-simple-vector ',(1+ (length (third info)))))))
                                            (when (and info *environment*)
                                              (list (list (sys.int::function-symbol '(setf sys.int::%svref))
                                                          (second (first *environment-chain*))
                                                          (second info)
                                                          ''0))))))
                                  (t (let ((info (assoc current-env new-envs)))
                                       (if info
                                           (let ((*environment-chain* (list* (list current-env (second info))
                                                                             *environment-chain*))
                                                 (*environment* (list* current-env *environment*)))
                                             (list (lower-env-form stmt)))
                                           (list (lower-env-form stmt)))))))))
        (if (endp new-envs)
            (frob-outer)
            `(let ,(loop for (stmt . env) in new-envs
                      collect (list env nil))
               ,(frob-outer))))))
  
  (defun le-return-from (form)
  