anchor.diff:  ;;;;
   ;;;;     - It has an UNWIND-INSTRUCTION as its predecessor.
   ;;;;
  +;;;;     - It has a predecessor with more than one successor.
  +;;;;
   ;;;;     Every leader defines exactly one basic block.
   ;;;;
   ;;;;   * Next, for each leader, we initialize a basic block consisting
  
positive.code: 	   (predecessors (node)
  	     (cleavir-ir:predecessors node)))
        (let ((table (make-hash-table :test #'eq)))
  	(labels ((traverse (node)
  		   (unless (gethash node table)
  		     (setf (gethash node table) t)
  		     (let ((preds (predecessors node)))
  		       (when (or (/= (length preds) 1)
  				 (typep (first preds)
  					'cleavir-ir:unwind-instruction))
  			 (setf (gethash node leaders) t))
  		       (mapc #'traverse (successors node))
  		       (when (typep node 'cleavir-ir:enter-instruction)
  			 (traverse (cleavir-ir:code node)))))))
  	  (traverse start-node)))
        (loop for first being each hash-key of leaders
  	    collect (loop for last = first then (car (successors last))
  			  for successors = (successors last)
  			  until (or (/= (length successors) 1)
  				    (gethash (first successors) leaders))
  			  finally (return (cons first last)))))))
  
negative.code: ;;;;     not a leader.
  
  ;;; Return a list of basic blocks.  Each basic block is represented as
  ;;; a list of three elements: the first instruction of the basic
  ;;; block, the last instruction of the basic block, and the OWNER of
  ;;; the basic block.  The owner of a basic block is either an ENTER
  ;;; instruction that represents the function to which the basic block
  ;;; belongs, or it is NIL if the basic block is outside the outermost
  ;;; ENTER instruction.
  (defun basic-blocks (start-node)
    (let ((leaders (make-hash-table :test #'eq)))
      (flet ((successors (node)
  