anchor.diff:             ;; Add new interference edges.
              (dolist (range live)
                (flet ((insert (vreg other)
  -                      (let ((interference (aref result vreg)))
  -                        (when (not interference)
  -                          (setf interference (make-vreg-set)
  -                                (aref result vreg) interference))
  -                        (insert-into-vreg-set interference other))))
  +                      (setf (svref result vreg) (insert-into-vreg-set (svref result vreg) other))))
                  (let ((other-vreg (live-range-vreg-id range)))
                    (when (and (not (eql other-vreg current-vreg))
  -                            (not (vreg-set-contains (aref result other-vreg) current-vreg)))
  +                            (not (vreg-set-contains (svref result other-vreg) current-vreg)))
                      (insert current-vreg other-vreg)
                      (insert other-vreg current-vreg)))))
              (push range live)))
  
positive.code:                (format t "   ~S~%" r))))
           (let ((current-range-start (live-range-start range))
                 (current-vreg (live-range-vreg-id range)))
             (insert-into-vreg-set spilled-vregs current-vreg)
             ;; Expire old ranges.
             (setf live (remove-if (lambda (x)
                                     (< (live-range-end x) current-range-start))
  
negative.code:     result))
  
  (defun make-vreg-set ()
    (make-array 0))
  
  (defun insert-into-vreg-set (set vreg)
    ;; Search for the position to insert into.
    (cond ((or (null set)
               (eql set vreg))
           vreg)
          ((typep set 'vreg-id)
           (let ((vec (make-array 2)))
             (if (< set vreg)
                 (setf (svref vec 0) set
                       (svref vec 1) vreg)
                 (setf (svref vec 0) vreg
                       (svref vec 1) set))
             vec))
          (t
           ;; IMIN/IMAX are inclusive indicies.
           (do* ((imin 0)
                 (imax (1- (length set))))
                ((< imax imin)
                 ;; Inserting at IMIN.
                 (let ((new (make-array (1+ (length set)))))
                   (replace new set :end2 imin)
                   (replace new set :start1 (1+ imin) :start2 imin)
                   (setf (svref new imin) vreg)
                   new))
             (declare (type simple-vector set))
             (let* ((imid (ash (+ imin imax) -1))
                    (entry (svref set imid)))
               (cond ((eql entry vreg)
                      ;; Already in the array, return.
                      (return set))
                     ((< entry vreg)
                      (setf imin (1+ imid)))
                     (t
                      (setf imax (1- imid)))))))))
  
  (defun vreg-set-contains (set vreg)
    (when (null set)
      (return-from vreg-set-contains nil))
    (when (typep set 'vreg-id)
      (return-from vreg-set-contains (eql set vreg)))
    (do* ((imin 0)
          (imax (1- (length set))))
         ((< imax imin)
          nil)
      (declare (type (vector t) set))
      (let* ((imid (ash (+ imin imax) -1))
             (entry (svref set imid)))
        (cond ((eql entry vreg)
               (return t))
              ((< entry vreg)
  