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: (defun opt-peephole-count (x)
    (or (href *opt-peephole-symbols* x) 0))
  
  (defun opt-peephole-rec (a d val fun name collect-symbols &optional (setq? nil))
    (with (plc (when (%setq? a)
  			   (%setq-place a))
  		 body (lambda-body val))
  	(with-temporary *opt-peephole-funinfo* (get-lambda-funinfo val)
  	  (with-temporary *opt-peephole-symbols* (? collect-symbols
  									            (opt-peephole-collect-syms body)
  										        *opt-peephole-symbols*)
          (let f (copy-lambda val :name name :body (funcall fun body))
  	      (cons (? setq?
  				   `(%setq ,plc ,f)
  				   f)
  		        (funcall fun d)))))))
  
  (defmacro opt-peephole-fun ((fun &key (collect-symbols nil)) &rest body)
    `(when 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*
  