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:       (incf score (cond (long-p 10)
                          ((and secondary-conj-p (not kanji-p)) 2)
                          ((and common-p conj-types-p) 5)
                          ((or prefer-kana (not entry) (= (n-kanji entry) 0)) 3)
                          (t 2))))
      (when (and particle-p (or final (not semi-final-particle-p)))
        (incf score 2)
  
negative.code:             (* prop-score (length-multiplier-coeff (- use-length len)
                                                     (if (and (> len 3) (or kanji-p katakana-p)) :ltail :tail))))
        (incf use-length-bonus
              (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 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 of-type fixnum from 1
                         for last = (= cnt nparts)
                         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 ptext 0 new-len) :kana ""))
                                         part)
                         for part-score = (calc-score tpart
                                                      :final (and final last)
  