anchor.diff:                                   :where (:or (:= 'kt.seq seq)
                                                (:= 'conj.from seq)))))
   
  +
  +;; (defmacro find-word-with-conj-prop (word condition)
  +;;   (alexandria:with-gensyms (table)
  +;;     `(let ((,table (if (test-word ,word :kana) 'kana-text 'kanji-text)))
  +;;        (query-dao ,table (:select 'kt.* :from (:as ,table 'kt)
  +;;                                   :inner-join (:as 'conjugation 'conj) :on (:= 'kt.seq 'conj.seq)
  +;;                                   :inner-join 'conj-prop :on (:= 'conj-id 'conj.id)
  +;;                                   :where (:and (:= 'kt.text ,word) ,condition))))))
  +
  +(defgeneric word-conj-data (word)
  +  (:documentation "conjugation data for word"))
  +
  +(defmethod word-conj-data ((word simple-text))
  +  (get-conj-data (seq word)))
  +
  +(defmethod word-conj-data ((word compound-text))
  +  (word-conj-data (car (last (words word)))))
  +
  +(defmacro find-word-with-conj-prop (word (conj-data-var) &body condition)
  +  `(remove-if-not (lambda (,conj-data-var) ,@condition) (find-word-full ,word) :key 'word-conj-data))
  +
  +(defmacro find-word-with-conj-type (word conj-type)
  +  `(find-word-with-conj-prop ,word (conj-data)
  +      (member ,conj-type conj-data :key (lambda (cdata) (conj-type (conj-data-prop cdata))))))
  +
   (defparameter *suffix-cache* nil)
   
   (defun init-suffixes ()
     (unless *suffix-cache*
       (setf *suffix-cache* (make-hash-table :test 'equal))
       (loop for kf in (get-kana-forms 2013800)
  -       do (setf (gethash (cons (text kf) :chau) *suffix-cache*) kf))))
  +       do (setf (gethash (cons (text kf) :chau) *suffix-cache*) kf))
  +    (loop for kf in (get-kana-forms  2017560)
  +       do (setf (gethash (cons (text kf) :tai) *suffix-cache*) kf))
  +    ))
   
   (defparameter *suffix-list* nil)
   
  
positive.code:                (let* ((,root-var (subseq ,str 0 ,pos))
                        (,primary-words (progn ,@get-primary-words)))
                   (mapcar (lambda (pw)
                             (make-instance 'compound-text
                                            :text ,str
                                            :kana (let ((k (get-kana pw)))
                                                    (concatenate 'string
                                                                 (subseq k 0 (- (length k) ,stem))
                                                                 (text ,suf)))
                                            :primary pw
                                            :words (list pw ,suf)
                                            :score-mod ,score))
                           ,primary-words)))))))))
    
           
  (conj-suffix suffix-chau ("ちゃ" :chau) (root)
    (loop with str = (concatenate 'string root "て")
       for word in (find-word str)
       for conj-data = (get-conj-data (seq word))
       if (member 3 conj-data
                  :key (lambda (cdata) (conj-type (conj-data-prop cdata))))
         collect word))
  
  (conj-suffix suffix-jau ("じゃ" :chau) (root)
    (loop with str = (concatenate 'string root "で")
       for word in (find-word str)
       for conj-data = (get-conj-data (seq word))
       if (member 3 conj-data
                  :key (lambda (cdata) (conj-type (conj-data-prop cdata))))
         collect word))
  
  (defun find-word-full (word)
    (init-suffixes)
  
negative.code:                   'n-kanji (:select (:count 'id) :from 'kanji-text :where (:= 'kanji-text.seq 'entry.seq))
                    'n-kana (:select (:count 'id) :from 'kana-text :where (:= 'kana-text.seq 'entry.seq)))))
  
  (defclass simple-text () ())
  
  (defclass kanji-text (simple-text)
    ((id :reader id :col-type serial)
     (seq :reader seq :col-type integer :initarg :seq)
     (text :reader text :col-type string :initarg :text)
  