anchor.diff:  								                            (remove-assignments .d))
                                                     2)))))
   
  +	   remove-vm-go-nil-heads
  +	     #'((x)
  +			  (opt-peephole-fun (#'remove-vm-go-nil-heads)
  +			    ((vm-go-nil-head? a d)
  +				   (cons `(%%vm-go-nil ,(%setq-value a) ,(caddr d.))
  +				          (remove-vm-go-nil-heads .d)))))
  +
          replace-tag
            #'((old-dest new-dest)
   			 (setf removed-tags (filter (fn ? (eq ._ old-dest)
  
positive.code: 	   (eq .a. ..a.)))
  
  (defun reversed-assignments? (a d)
    (and (%setq? a)
  	   (%setq? d.)
         .a.
  	   (atom .a.)
  	   (eq .a. (caddr d.))
  	   (eq (cadr d.) ..a.)))
  
  (defun jump-to-following-tag? (a d)
    (and (%%vm-go? a)
  	   d
  	   (atom d.)
  	   (eq .a. d.)))
  
  ;; Remove unreached code or code that does nothing.
  (defun opt-peephole-remove-void (x)
  
negative.code: 	  ((%%vm-go? a) (cons a (opt-peephole-remove-void (opt-peephole-find-next-tag d))))))
  
  (defun opt-peephole-will-be-used-again? (x v)
    (with (traversed-tags nil
           rec #'((x v)
                   (?
                     (and (not (~%ret? v))
                          (transpiler-defined-variable *current-transpiler* v)) t
  	               (funinfo-immutable? *opt-peephole-funinfo* v)	t
  	               (not x)			(~%ret? v)	; End of block always returns ~%RET.
  	               (atom x)		(error "illegal meta-code: statement expected")
  	               (lambda? x.)	(rec .x v)
                     (%%vm-go? x.) (let tag (cadr x.)
                                     (aif (member tag *opt-peephole-body* :test #'eq)
                                          (or (member tag traversed-tags :test #'eq)
                                              (progn
                                                (push tag traversed-tags)
                                                (rec .! v)))
                                          t))
                     (vm-jump? x.)   t
                     (? (and (%setq? x.) (eq v (%setq-place x.)))
  	                  (find-tree (%setq-value x.) v :test #'eq)
                        (or (find-tree x. v :test #'eq) ; Place used in statement?
                            (rec .x v))))))
      (rec x v)))
  
  (defun removable-place? (v)
    (let fi *opt-peephole-funinfo*
  