anchor.diff:           (primary-p nil)
            (use-length-bonus 0)
            split-info)
  +    (declare (type (integer 0 1000000) score prop-score use-length-bonus)
  +             (type (integer 0 10000) len ord n-kanji)
  +             (type (or fixnum (eql :null)) common)
  +             (type string text))
       (when (or (intersection seq-set *skip-words*)
                 (and (not final) (member seq *final-prt*))
                 (and (not root-p) (skip-by-conj-data conj-data)))
  
positive.code:         (when conj-of-data
            (unless common-p
              (let ((conj-of-common (mapcan (lambda (row) (unless (eql (car row) :null) (list (car row)))) conj-of-data)))
                (when conj-of-common
                  (setf common 0 common-p t common-of (car (sort conj-of-common #'compare-common))))))
            (let ((conj-of-ord (reduce 'min conj-of-data :key 'second)))
              (when (< conj-of-ord ord) (setf ord conj-of-ord))))))
  
      (unless is-arch
  
negative.code:     (:tail 4 9 16 24)
      (:ltail 4 12 18 24)))
  
  (declaim (inline length-multiplier-coeff))
  (declaim (ftype (function ((integer 0 10000) (member :strong :weak :tail :ltail)) (integer 0 120000)) length-multiplier-coeff))
  (defun length-multiplier-coeff (length class)
    (declare (optimize (speed 3) (debug 1) (safety 1)))
    (let ((coeffs (assoc class *length-coeff-sequences*)))
      (declare (type list coeffs))
      (if (< 0 length (length coeffs))
          (elt coeffs length)
          (* length (the (integer 0 1000) (/ (the integer (car (last coeffs))) (1- (length coeffs))))))))
  
  (defun kanji-break-penalty (kanji-break score &key info text use-length score-mod)
    (let ((end (cond ((cdr kanji-break) :both)
  