anchor.diff:  	 (setf cheapest lexical-location))))
       cheapest))
   
  -(defun pseudo-allocate-registers (program)
  -  (make program 'datum-assign-use)
  -  (let ((lexical-locations '())
  -	(registers (registers (backend program)))
  -	(conflicts (compute-conflicts program)))
  +(defun all-lexical-locations ()
  +  (let ((lexical-locations '()))
       (map-lexical-locations
        (lambda (lexical-location)
          (push lexical-location lexical-locations)))
  -    (loop for solution = (sicl-graph-coloring:solve registers
  +    lexical-locations))
  +  
  +(defparameter *temp-counter* 0)
  +
  +(defun pseudo-allocate-registers (program)
  +  (let ((registers (registers (backend program))))
  +    (loop for lexical-locations = (all-lexical-locations)
  +	  for conflicts = (compute-conflicts program)
  +	  for solution = (sicl-graph-coloring:solve registers
   						    lexical-locations
   						    conflicts
   						    #'required-register
  
positive.code: (set-processor 'no-constant-inputs 'replace-constant-inputs)
  
  (add-dependencies 'no-constant-inputs
  		  '())
  
  ;;; Insert a LOAD-EXTERNAL instruction before INSTRUCTION, with
  ;;; IN as its single input and OUT as its single output.
  
negative.code: 	       ;; We don't want to spill this one again.
  	       (setf (spill-cost new) t)
  	       (sicl-mir:insert-instruction-before assignment inst)
  	       (setf (inputs inst)
  		     (substitute new lexical-location (inputs inst)
  				 :test #'eq)))))
    (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
  				 new lexical-location inst)))
  	       ;; We don't want to spill this one again.
  	       (setf (spill-cost new) t)
  	       (sicl-mir:insert-instruction-after assignment inst)
  