                                                                     :top)]
                                                 (unify unify-against
                                                        conjugate-with)))))
-                                              
-                               (string/replace infinitive from to))))
+                               (do
+                                 (log/debug (str "regular: matched: from: " from "; infinitive: "
+                                                 infinitive " with "
+                                                 "unify-against: " (strip-refs (:u replace-pattern)) ";"
+                                                 "conjugate-with:" (strip-refs conjugate-with)))
+                                 (string/replace infinitive from to))))))
                          regular-patterns))]
             (let [results (concat exceptional-surface-forms regulars [infinitive])]
               (log/debug (if (not (empty? exceptional-surface-forms))

                                                          :exception true}}))))
                
                exceptional-surface-forms
                (remove nil?
                        (map #(let [{path :path
                                     prefix :prefix
                                     suffix :suffix
                                     unify-with :unify-with} %]
                                (if (not (= :fail (unify unify-with spec)))
                                  (cond (and (not (nil? prefix))
                                             (not (nil? suffix)))
                                        (str (get-in spec [:français prefix]) suffix)

                                        (not (nil? path))
                                        (get-in spec path)
                                        
                                        true (throw (Exception. (str "problem with irregular pattern:" %))))))
                             verbs/irregular-conjugations))
                
                regulars
                (remove nil?

                         (fn [replace-pattern]
                           (let [from (nth (:g replace-pattern) 0)
                                 to (nth (:g replace-pattern) 1)]
                             (when (and from to infinitive (re-matches from infinitive))
                             (if (and from to infinitive
                                      (re-matches from infinitive)
                                      (not (= :fail
