anchor.diff:  	       (sicl-mir:insert-instruction-before assignment inst)
   	       (nsubstitute new lexical-location (inputs inst)
   			    :test #'eq))))
  -  (loop for inst in (assigning-instructions lexical-location)
  +  (loop for inst in (defining-instructions lexical-location)
   	do (unless (typep inst 'sicl-mir:assignment-instruction)
   	     (let* ((new (sicl-mir:new-temporary))
   		    (assignment (sicl-mir:make-assignment-instruction
  
positive.code: ;;;
  ;;; The conflicts are computed in the same way as for the register
  ;;; allocator.  For now, we use a very crude estimate of the number of
  ;;; definitions/uses.  We just count the number of assigning and using
  ;;; instructions, except that if an instruction is part of a loop, we
  ;;; count it as 10 instead of as 1.  We could do much better here, by
  ;;; counting nested loops and by taking branches into account.
  
negative.code: (defun compute-spill-costs (program)
    (let* ((loops (remove 1 (sicl-compiler-loops:kosaraju
  			   (initial-instruction program) #'successors)
  			:key #'length))
  	 (loop-instructions (reduce #'append loops :from-end t))
  	 (conflicts (compute-conflicts program)))
      (map-lexical-locations
  