anchor.diff:                         (dolist (comp (word-info-components word-info))
                            (terpri s)
                            (inner comp (not (word-info-primary comp)) t)))
  -                     (let ((seq (word-info-seq word-info)) desc)
  -                       (if (and suffix (setf desc (get-suffix-description seq)))
  -                           (format s "  [suffix]: ~a " desc)
  -                           (progn (terpri s) (princ (if seq (get-senses-str seq) "???") s)))
  +                     (let ((seq (word-info-seq word-info)) 
  +                           (conjs (word-info-conjugations word-info))
  +                           desc)
  +                       (cond ((and suffix (setf desc (get-suffix-description seq)))
  +                              (format s "  [suffix]: ~a " desc))
  +                             ((or (not conjs) (eql conjs :root))
  +                              (terpri s) (princ (if seq (get-senses-str seq) "???") s)))
                          (when seq
  -                         (print-conj-info seq s))))))
  +                         (print-conj-info seq :out s
  +                                          :conjugations conjs))))))
           (if (word-info-alternative word-info)
               (loop for wi in (word-info-components word-info)
                    for i from 1
  
positive.code:                                                          :text (get-text wrd)
                                                           :kana (get-kana wrd)
                                                           :seq (seq wrd)
                                                           :primary (= (id wrd) primary-id))))
                   :score (segment-score segment)
                   :start (segment-start segment)
  
negative.code:            (format out "~%  ~a" (entry-info-short (seq-from conj)))
             (progn
               (format out "~% --(via)--")
               (print-conj-info via :out out)
               (push via via-used)))
         (princ " ]" out)))
  
  (defun conj-info-json (seq &key conjugations)
    (loop with via-used = nil
       for conj in (select-conjs seq conjugations)
       for via = (seq-via conj)
       unless (member via via-used)
       collect (let* ((conj-pos nil)
  