anchor.diff:                                             (member (car item) original-readings :test 'equal))
                                            (row-major-aref matrix ii))
                  when readings
  -               do (when (insert-conjugation readings :seq next-seq
  -                                            :from seq :pos pos
  +               do (when (insert-conjugation readings :seq next-seq :via via
  +                                            :from seq* :pos pos
                                               :conj-id conj-id
                                               :neg (if ignore-neg :null neg)
                                               :fml (if ignore-fml :null fml))
  
positive.code:                                                               (:select 'text 'ord 0 :from 'kana-text
                                                                         :where (:and (:= 'seq seq) 'conjugate-p))))
                 do (loop for rule in rules
                         for conj-id = (cr-conj rule)
                         for key = (list pos-id conj-id)
                         for conj-text = (construct-conjugation reading rule)
                       do (unless (gethash key conj-matrix)
                            (setf (gethash key conj-matrix)
                                  (make-array '(2 2) :initial-element nil)))
                         (push (list conj-text kanji-flag ord (cr-onum rule))
                               (aref (gethash key conj-matrix)
                                     (if (cr-neg rule) 1 0)
                                     (if (cr-fml rule) 1 0)))))
           finally (return conj-matrix))))
  
  (defun conjugate-entry-outer (seq)
    (let* ((conj-matrix (conjugate-entry-inner seq))
           (original-readings (get-all-readings seq))
           (max-seq (query (:select (:max 'seq) :from 'entry) :single))
           (next-seq (1+ max-seq)))
  
negative.code: 
  (defmethod print-object ((obj conjugation) stream)
    (print-unreadable-object (obj stream :type t :identity nil)
      (let ((via (seq-via obj)))
        (if (eql via :null)
            (format stream "~a -> ~a" (seq-from obj) (seq obj))
            (format stream "~a -> ~a -> ~a" (seq-from obj) (seq-via obj) (seq obj))))))
  
  (defclass conj-prop ()
    ((id :reader id :col-type serial)
  