               
             true
             (let [infinitive (get-in word [:français])
-                  result (conjugate infinitive {:synsem word})]
+                  debug (log/debug (str "input to conjugate: infinitive: " infinitive "; spec:"
+                                         (strip-refs word)))
+                  synsemize ;; convert _word_ back into what (defn conjugate) can deal with.
+                  (pre-conjugate {:français word})
+                  result (conjugate infinitive synsemize)]
               (log/debug (str "result of conjugate: " result))
               result)))))
-  
+ 
 (defn fo [input &
           {:keys [from-language show-notes]
            :or {from-language nil

(defn lookup-in [lexicon {spec :spec}]
  (let [infinitive (get-in spec [:français :infinitive])
        lexemes (reduce concat (vals lexicon))]
    (if (fail? spec)
      (throw (Exception. (str "lookup-in was given spec=fail."))))
    (filter (fn [lexeme]
              (and

   conjugate-with. If lexicon is supplied, look up infinitive in lexicon and use exceptional form of
   first return value, if any."
  (if (nil? infinitive)
    (throw (Exception. (str "conjugate passed null infinitive."))))
  (if (= :top (get-in conjugate-with [:synsem :cat] :top))
    (if false (throw (Exception. (str "conjugate: no [:synsem :cat] supplied: infinitive: " infinitive "; conjugate-with: " (strip-refs conjugate-with))))
        (do
          (log/warn (str "conjugate: no [:synsem :cat] supplied: infinitive: " infinitive "; conjugate-with: " (strip-refs conjugate-with))))))
  (if (and
       (= :verb (get-in conjugate-with [:synsem :cat]))
       (= :top (get-in conjugate-with [:synsem :agr] :top)))
    (do
      (log/warn (str "conjugate: no [:synsem :agr] supplied: infinitive: " infinitive "; conjugate-with: " (strip-refs conjugate-with)))
      nil))

  (let [diag
        (log/debug (str "conjugate: infinitive=" infinitive "; conjugate-with: "
                        (strip-refs conjugate-with)))
        
        lookup-spec (strip-refs (unify
                                 (dissoc-paths
                                  conjugate-with [[:français :exception]])
                                 {:français {:infinitive infinitive
                                             :exception true}}))
        diag
        (log/debug (str "conjugate: lookup-spec: " lookup-spec))
        
        diag
        (if (fail? lookup-spec)
          (log/debug (str "fail-path for conjugate-with:"
                          (strip-refs conjugate-with) "; "
                          {:français {:infinitive infinitive
                                      :exception true}} ": "
                          (dag_unify.core/fail-path
                           conjugate-with
                           {:français {:infinitive infinitive
                                       :exception true}}))))
        exceptional-lexemes
        (lookup-in lexicon
                   {:spec lookup-spec})
        
        exceptional-surface-forms
        (map #(get-in % [:français :français])
             exceptional-lexemes)
        
        regulars
        (remove nil?
                (map
                 (fn [replace-pattern]
                     (let [from (nth (:g replace-pattern) 0)
                           to (nth (:g replace-pattern) 1)
                           unify-against (if (:u replace-pattern)
