anchor.diff:  ;;;      maximum depth of any of its lexical parents. 
   
   (defun data (instruction)
  -  (append (cleavir-mir:inputs instruction)
  -	  (cleavir-mir:outputs instruction)))
  +  (append (cleavir-ir:inputs instruction)
  +	  (cleavir-ir:outputs instruction)))
   
   (defvar *ownerships*)
   
  
positive.code:     (labels ((traverse (instruction)
  	       (unless (gethash instruction visited)
  		 (setf (gethash instruction visited) t)
  		 (loop with type = 'cleavir-mir:lexical-location
  		       for datum in (data instruction)
  		       do (when (and (typep datum type)
  				     (/= (lexical-depth datum)
  					 (lexical-depth instruction)))
  			    (change-class datum
  					  'cleavir-mir:indefinite-lexical-location)))
  		 (loop for succ in (cleavir-mir:successors instruction)
  		       do (traverse succ))
  		 (when (typep instruction 'cleavir-mir:enclose-instruction)
  		   (traverse (cleavir-mir:code instruction))))))
        (traverse enter-instruction))
      ;; Next find all lexical locations that were not converted in the
      ;; first step, and convert them to simple lexical locations.  It
  
negative.code:     (labels ((traverse (instruction)
  	       (unless (gethash instruction visited)
  		 (setf (gethash instruction visited) t)
  		 (loop with type = '(and cleavir-ir:lexical-location
  				         (not cleavir-ir:indefinite-lexical-location))
  		       for datum in (cleavir-ir:outputs instruction)
  		       do (when (typep datum type)
  			    (change-class datum
  					  'cleavir-ir:dynamic-lexical-location)))
  		 (loop for succ in (cleavir-ir:successors instruction)
  		       do (traverse succ))
  		 (when (typep instruction 'cleavir-ir:enclose-instruction)
  		   (traverse (cleavir-ir:code instruction))))))
        (traverse enter-instruction))
      (incf *ld3-call-count*)
      (incf *ld3-node-count* (hash-table-count visited))
  