anchor.diff:              (* prop-score (length-multiplier-coeff (- use-length len)
                                                      (if (and (> len 3) (or kanji-p katakana-p)) :ltail :tail))))
         (incf use-length-bonus
  -            (apply-score-mod score-mod prop-score (- use-length len)))
  +            (the (integer 0 10000) (apply-score-mod score-mod prop-score (- use-length len))))
         (incf score use-length-bonus))
   
       (unless ctr-mode
         (multiple-value-bind (split score-mod-split) (get-split reading conj-of)
  +        (declare (type (or null (integer -10000 10000)) score-mod-split))
           (cond
             ((member :score split)
              (incf score score-mod-split)
              (setf split-info score-mod-split))
             ((member :pscore split)
              (let ((new-prop-score (max 1 (+ prop-score score-mod-split))))
  -             (setf score (ceiling (* (/ score prop-score) new-prop-score))
  +             (setf score (ceiling (* score new-prop-score) prop-score)
                      prop-score new-prop-score)))
             (split
              (setf score
                    (+ score-mod-split
                       (loop with nparts = (length split)
                          for part in split
  -                       for cnt from 1
  +                       for cnt of-type fixnum from 1
                          for last = (= cnt nparts)
  -                       for plen = (length (text part))
  -                       for slen = plen then (+ slen plen)
  -                       for pmlen = (mora-length (text part))
  -                       for smlen = pmlen then (+ smlen pmlen)
  +                       for ptext of-type vector = (text part)
  +                       for plen of-type fixnum = (length ptext)
  +                       for slen of-type fixnum = plen then (+ slen plen)
  +                       for pmlen of-type (integer 0 10000) = (mora-length (text part))
  +                       for smlen of-type (integer 0 10000) = pmlen then (+ smlen pmlen)
                          for tpart = (if (and last (> slen (length text)))
                                          (let ((new-len (max 1 (+ plen (- (length text) slen)))))
  -                                         (make-instance 'proxy-text :source part :text (subseq (text part) 0 new-len) :kana ""))
  +                                         (make-instance 'proxy-text :source part :text (subseq ptext 0 new-len) :kana ""))
                                          part)
                          for part-score = (calc-score tpart
                                                       :final (and final last)
  
positive.code:     (:tail 4 9 16 24)
      (:ltail 4 12 18 24)))
  
  (defun length-multiplier-coeff (length class)
    (let ((coeffs (assoc class *length-coeff-sequences*)))
      (if (< 0 length (length coeffs))
          (elt coeffs length)
          (* length (/ (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)
  
negative.code:     (counter-text
       (setf ctr-mode t)))
  
    (let* ((score 1) (prop-score 0)
           (kanji-p (eql (word-type reading) :kanji))
           (katakana-p (and (not kanji-p) (> (the fixnum (count-char-class (true-text reading) :katakana-uniq)) 0)))
           (text (text reading))
           (n-kanji (count-char-class text :kanji))
           ;(kanji-prefix (kanji-prefix text))
           (len (max 1 (the fixnum (mora-length text))))
           (seq (the (or null fixnum) (seq reading)))
           (ord (ord reading))
           (entry (and seq (get-dao 'entry seq)))
           (conj-only (let ((wc (word-conjugations reading))) (and wc (not (eql wc :root)))))
  