anchor.diff:                        
   (defun dict-segment (str &key (limit 5))
     (with-connection *connection*
  -    (loop for (path . score) in (find-best-path^2-1 (join-substring-words str) :limit limit)
  +    (loop for (path . score) in (find-best-path* (join-substring-words str) :limit limit)
            collect (cons (fill-segment-path str path) score))))
   
   (defun simple-segment (str &key (limit 5))
  
positive.code:     (loop for tai across (get-array top)
           collect (cons (reverse (tai-payload tai)) (tai-score tai)))))
  
  (defun find-best-path^2-1 (segment-lists &key (limit 5))
    "convert find-best-path^2 results to previous format"
    (let ((result (find-best-path^2 segment-lists :limit limit)))
      (dolist (item result result)
        (setf (car item)
              (mapcan (lambda (obj)
  
negative.code:   (loop for fn in *synergy-list*
       nconc (funcall fn segment-list-left segment-list-right)))
  
  (defun find-best-path (segment-lists &key (limit 5))
    "generalized version of old find-best-path that operates on segment-lists and uses synergies"
    (let ((top (make-instance 'top-array :limit limit)))
      (register-item top 0 nil)
  
      (dolist (segment-list segment-lists)
        (setf (segment-list-top segment-list) (make-instance 'top-array :limit limit)))
  
      ;;assume segments are sorted by (start, end) (as is the result of find-substring-words)
      (loop for (seg1 . rest) on segment-lists
           for score1 = (get-segment-score seg1)
         when (> score1 0) do 
  