                                                                     :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))

                         (fn [replace-pattern]
                           (let [from (nth (:g replace-pattern) 0)
                                 to (nth (:g replace-pattern) 1)]
                             (when (and from to infinitive)
                               (log/debug (str "from: " from "; infinitive: " infinitive " => "
                                               (re-matches from infinitive)))
                               (log/debug (if (re-matches from infinitive)
                                            (str "matched: from: " from "; infinitive: "
                                                 infinitive " with "
                                                 "unify-against: " (strip-refs (:u replace-pattern)) ";"
                                                 "conjugate-with:" (strip-refs conjugate-with)))))
                             (if (and from to infinitive
                                      (re-matches from infinitive)
                                      (not (= :fail

                                                          :exception true}}))))
                
                exceptional-surface-forms
                (do
                  (log/debug (str "unifying spec: " spec " against irregular-conjugations."))
                  (remove nil?
                          (map #(let [{path :path
                                       prefix :prefix
                                       suffix :suffix
                                       unify-with :unify-with} %]
                                  (log/debug (str "irregular: trying 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:" %))))
                                    (do (log/debug (str "irregular: unify failed: fail-path: "
                                                        (dag_unify.core/fail-path unify-with spec)))
                                        nil)))
                               verbs/irregular-conjugations)))
                
                regulars
                (remove nil?
