anchor.diff:      (labels ((traverse (instruction)
   	       (unless (gethash instruction visited)
   		 (setf (gethash instruction visited) t)
  -		 (loop with type = '(and cleavir-mir:lexical-location
  -				         (not cleavir-mir:indefinite-lexical-location))
  -		       for datum in (cleavir-mir:outputs instruction)
  +		 (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-mir:dynamic-lexical-location)))
  -		 (loop for succ in (cleavir-mir:successors instruction)
  +					  'cleavir-ir:dynamic-lexical-location)))
  +		 (loop for succ in (cleavir-ir:successors instruction)
   		       do (traverse succ))
  -		 (when (typep instruction 'cleavir-mir:enclose-instruction)
  -		   (traverse (cleavir-mir:code instruction))))))
  +		 (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))
  
positive.code: 		    (loop for datum in (data instruction)
  			  do (when (null (owner datum))
  			       (setf (owner datum) enter-instruction)))
  		    (when (typep instruction 'cleavir-mir:enclose-instruction)
  		      (let ((code (cleavir-mir:code instruction)))
  			(setf worklist (append worklist (list code)))))
  		    (mapc #'traverse (cleavir-mir:successors instruction)))))
  	     (traverse enter-instruction))))
        (loop until (null worklist)
  	    do (process-function (pop worklist))))
  
negative.code: ;;;      maximum depth of any of its lexical parents. 
  
  (defun data (instruction)
    (append (cleavir-ir:inputs instruction)
  	  (cleavir-ir:outputs instruction)))
  
  (defvar *ownerships*)
  
  