anchor.diff:  
   (defun simp-block (form)
     (cond
  -     ((eql (lexical-variable-use-count (second form)) 0)
  -      (change-made)
  -      (simp-form `(progn ,@(cddr form))))
  -     ;; (block foo (return-from foo form)) => form
  -     ((and (eql (lexical-variable-use-count (second form)) 1)
  -           (eql (length form) 3)
  -           (eql (first (third form)) 'return-from)
  -           (eql (second form) (second (third form))))
  -      (third (third form)))
  -     (t (simp-implicit-progn (cddr form) t)
  -	form)))
  +    ;; Unused blocks get reduced to progn.
  +    ((eql (lexical-variable-use-count (second form)) 0)
  +     (change-made)
  +     (simp-form `(progn ,@(cddr form))))
  +    ;; (block foo) => 'nil
  +    ((eql (length form) 2)
  +     (change-made)
  +     'nil)
  +    ;; (block foo ... (return-from foo form)) => (block foo ... form)
  +    ((and (listp (first (last form)))
  +          (eql (first (first (last form))) 'return-from)
  +          (eql (second form) (second (first (last form)))))
  +     (change-made)
  +     (setf (first (last form)) (third (first (last form))))
  +     form)
  +    (t (simp-implicit-progn (cddr form) t)
  +       form)))
   
   (defun simp-go (form)
     ;; HACK: Update the tagbody location part after tagbodies have merged.
  
positive.code: 		(change-made)
  		(setf (cdr tail) (cons x nil)
  		      tail (cdr tail)))
  	    (setf (cdr tail) (flatten x)
  		  tail (last tail)))))
      ;; Reduce tagbodys with no tags to progn.
      (cond ((tagbody-information-go-tags (second form))
  	   form)
  
negative.code:                    (return-from ,new-block ,(simp-form (third form)) ,new-block)
                     ,else-tag
                     (return-from ,new-block ,(simp-form (fourth form)) ,new-block)))))
            ((and (listp (third form))
                  (eql (first (third form)) 'go)
                  (listp (fourth form))
                  (eql (first (fourth form)) 'go)
                  (eql (second (third form)) (second (fourth form)))
                  (eql (third (third form)) (third (fourth form))))
             ;; Rewrite (if x (go A-TAG) (go A-TAG)) => (go A-TAG)
             (change-made)
             (simp-form (third form)))
            (t
             (setf (second form) (simp-form (second form))
                   (third form) (simp-form (third form))
  