                          (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

  "Conjugate an infinitive into a surface form by taking the first 
   element of regular-patterns where the element's :u unifies successfully with
   conjugate-with."
  (let [underspecified?
        (or 
         (= :top (get-in conjugate-with [:synsem :cat] :top))

                               (string/replace infinitive from to))))
                         regular-patterns))]
            (let [results (concat exceptional-surface-forms regulars [infinitive])]
              (log/debug (if (not (empty? exceptional-surface-forms))
                           (str "conjugate: exceptional conjugation: " (first exceptional-surface-forms))
                           (if (not (empty? regulars))
                             (str "conjugate: regular conjugation: " (first regulars)))))
              (first results))))))
  
(defn pre-conjugate [spec]
