anchor.diff:  
   (defparameter *do-not-conjugate* '("n" "vs" "adj-na"))
   
  -(defun conjugate-entry-inner (seq)
  -  (let ((posi (query (:select 'text :distinct :from 'sense-prop
  -                              :where (:and (:= 'tag "pos") (:= 'seq seq))) :column)))
  +(defparameter *pos-with-conj-rules*
  + '("adj-i" "adj-ix" "cop-da" "v1" "v1-s" "v5aru" 
  +   "v5b" "v5g" "v5k" "v5k-s" "v5m" "v5n" "v5r" "v5r-i" "v5s"
  +   "v5t" "v5u" "v5u-s" "vk" "vs-s" "vs-i"))
  +
  +(defparameter *secondary-conjugation-types-from* '(5 6 7 8))
  +
  +(defparameter *secondary-conjugation-types* '(2 3 4 9 10 11 12 13))
  +
  +(defun conjugate-entry-inner (seq &key conj-types as-posi)
  +  (let ((posi (or as-posi (query (:select 'text :distinct :from 'sense-prop
  +                                          :where (:and (:= 'tag "pos") (:= 'seq seq))) :column))))
       (loop with conj-matrix = (make-hash-table :test 'equal) ;; (cons pos-id conj-id) -> 2x2 array
          for pos in posi
          for pos-id = (get-pos-index pos)
  
positive.code:            do (conjugate-entry-outer seq)
             if (zerop (mod cnt 500)) do (format t "~a entries processed~%" cnt)))))
  
  
  ;;; end conjugations
  
  
negative.code:                                    :group-by 'r.seq
                                     :having (:= (:count 'r.id) (length kana-readings)))
                            :column))))
           (when (or (member from seq-candidates) (member via seq-candidates))
             (return nil))
           (if seq-candidates
               (setf seq (car seq-candidates))
               (progn
                 (make-dao 'entry :seq seq :content "")
                 (let ((conjugate-p (when (member conj-id *secondary-conjugation-types-from*) t)))
                   (loop for kr in kanji-readings
                      for ord from 0
                      do (make-dao 'kanji-text :seq seq :text kr :ord ord :common :null :conjugate-p conjugate-p))
                   (loop for kr in kana-readings
                      for ord from 0
                      do (make-dao 'kana-text :seq seq :text kr :ord ord :common :null :conjugate-p conjugate-p)))))
           
           (let* ((old-conj (if via
                                (select-dao 'conjugation (:and (:= 'from from) (:= 'seq seq) (:= 'via via)))
                                (select-dao 'conjugation (:and (:= 'from from) (:= 'seq seq) (:is-null 'via)))))
                  (conj (or (car old-conj) (make-dao 'conjugation :seq seq :from from :via (or via :null)))))
             (make-dao 'conj-prop :conj-id (id conj) :conj-type conj-id :pos pos :neg neg :fml fml))
           (return (not seq-candidates)))))
  
  (defun load-conjugations ()
    (with-connection *connection*
  