anchor.diff:              (collect end))
             (sort (lambda (a b) (- a b)))))
   
  -       (defun %overlap-p (start1 end1 start2 end2)
  -         (not (or (> start1 end2) (> start2 end1))))
  +       (define-react-class hilited-segment
  +           (if (> (prop opinions length) 0)
  +               (psx
  +                (:span
  +                 :style (create font-weight :bold)
  +                 :on-click (@ this handle-click)
  +                 (rebreak (prop text))
  +                 (:span :style (create position :relative)
  +                        (%make-opin-popups (if (and (not (prop not-viewable))
  +                                                    (state viewable))
  +                                               (prop opinions)
  +                                               ([]))))))
  +               (psx
  +                (:span :style (create font-weight :normal)
  +                       (rebreak (prop text)))))
  +         get-initial-state
  +         (lambda () (create viewable false))
  +         handle-click
  +         (lambda () (unless (prop not-viewable)
  +                      (set-state viewable (not (state viewable))))))
   
  -       (defun %make-segments (text opins)
  +       (defun %make-segments (text opins focus)
            (collecting
              (let ((segpoints (excerpt-segment-points
                                (collecting (dolist (op opins) (collect (@ op 0))))
  
positive.code:                                                   (/ (lisp *opin-box-height*)
                                                       (lisp *minimum-space*))))
           (let* ((div (chain -math (floor (/ number rankmax))))
                  (mod (mod number rankmax))
                  (ranks (+ div (if (< 0 mod) 1 0)))
                  (ranksize (chain -math (floor (/ number ranks))))
                  (longranks (mod number ranks)))
             (collecting
               (dotimes (i (- ranks longranks))
                 (collect ranksize))
  
negative.code:                     (collect (psx (:br :key (unique-id))))))
                  (slice 0 -1)))
  
         (defun %overlap-p (start1 end1 start2 end2)
           (not (or (> start1 end2) (> start2 end1))))
  
         ;;Find all the indices where excerpts start or stop.
         (defun excerpt-segment-points (opset end)
           (chain
  