anchor.diff:    (sb-thread:with-mutex (*init-suffixes-lock* :wait-p nil)
       (init-suffix-hashtables)
       (with-connection *connection*
  -      (labels ((load-kf (key kf &key class text)
  -                 (setf (gethash (or text (text kf)) *suffix-cache*) (list key kf)
  -                       (gethash (seq kf) *suffix-class*) (or class key)))
  -               (load-conjs (key seq &optional class)
  +      (labels ((update-suffix-cache (text new &key join)
  +                 (let ((old (gethash text *suffix-cache*)))
  +                   (setf (gethash text *suffix-cache*)
  +                         (cond
  +                           ((not old) new)
  +                           ((and join (consp (car old)))
  +                            (cons new old))
  +                           (join
  +                            (list new old))
  +                           (t
  +                            ;;(format t "Overwriting ~a (was ~a, now ~a)~%" text old new)
  +                            new)))))
  +               (load-kf (key kf &key class text join)
  +                 (update-suffix-cache (or text (text kf)) (list key kf) :join join)
  +                 (setf (gethash (seq kf) *suffix-class*) (or class key)))
  +               (load-conjs (key seq &optional class join)
                    (loop for kf in (get-kana-forms seq)
  -                    do (load-kf key kf :class class)))
  -               (load-abbr (key text)
  -                 (setf (gethash text *suffix-cache*) (list key nil))))
  +                    do (load-kf key kf :class class :join join)))
  +               (load-abbr (key text &key join)
  +                 (update-suffix-cache text (list key nil) :join join)))
   
           (load-conjs :chau 2013800) ;; ちゃう
           (load-conjs :chau 2210750) ;; ちまう
  
positive.code: 
          (load-abbr :nakereba "なきゃ")
          (load-abbr :nakereba "なくちゃ")
  
          (load-abbr :shimashou "しましょ")
          (load-abbr :dewanai "じゃない")
  
negative.code: 
  (pushnew :dewanai *suffix-unique-only*)
  
  
  (def-abbr-suffix abbr-eba :eba 2 (root)
    (find-word-full (concatenate 'string root "えば")))
  
  (def-abbr-suffix abbr-teba :teba 2 (root)
    (find-word-full (concatenate 'string root "てば")))
  
  (def-abbr-suffix abbr-reba :reba 2 (root)
    (find-word-full (concatenate 'string root "れば")))
  
  (def-abbr-suffix abbr-keba :keba 2 (root)
    (find-word-full (concatenate 'string root "けば")))
  
  (def-abbr-suffix abbr-geba :geba 2 (root)
    (find-word-full (concatenate 'string root "げば")))
  
  (def-abbr-suffix abbr-neba :neba 2 (root)
    (find-word-full (concatenate 'string root "ねば")))
  
  (def-abbr-suffix abbr-beba :beba 2 (root)
    (find-word-full (concatenate 'string root "べば")))
  
  (def-abbr-suffix abbr-meba :meba 2 (root)
    (find-word-full (concatenate 'string root "めば")))
  
  (def-abbr-suffix abbr-seba :seba 2 (root)
    (find-word-full (concatenate 'string root "せば")))
  
  
  (defun parse-suffix-val (substr val)
    (when val
      (cond ((consp (car val))
             (loop for v in val collect (cons substr v)))
            (t (list (cons substr val))))))
  
  (defun get-suffix-map (str)
    (init-suffixes)
    (let ((result (make-hash-table)))
  