                                                        (let [debug (log/debug (str "generating from spec(pre-person):" spec))
                                                              unify-with {:comp {:synsem {:agr {:person person}}}}
                                                              unified (unify/unify spec unify-with)
-                                                             
+                                                             debug (if (fail? unified)
+                                                                     (do
+                                                                       (log/info (str "spec=fail:tried to generate with spec(pre-person):" spec))
+                                                                       (log/info (str "spec=fail:tried to generate with unify-with      : " unify-with))))
                                                              spec
                                                              (if (fail? unified)
-                                                               (let [message
-                                                                     (log/warn (str "could not unify " spec " with person specification:" unify-with "."))]
+                                                               (let [message (str "could not unify " spec " with person specification:" unify-with ".")]
                                                                  (if true
                                                                    (do
-                                                                     (log/warn message)
-                                                                     (log/warn (str "Ignoring and continuing."))
+                                                                     (log/debug message)
+                                                                     (log/debug (str "Ignoring and continuing."))
                                                                      unified)
                                                                    (do
                                                                      (log/error message)

                                                                                   (= (get-in spec [:synsem :sem :aspect])
                                                                                      :progressive))))
                                                                         (log/info (str "ignoring exception(llamarse-is-only-singular and present): " e))

                                                                         true
                                                                         (do

                                                                                         {:comp {:synsem {:agr {:number number}}}})]
                                                                   (log/debug (str "generating from spec(2): " spec))
                                                                   (try
                                                                     (if (fail? spec)
                                                                       (do
                                                                         (log/debug (str "ignoring failed spec."))
                                                                         0)
                                                                       (process [{:fill-one-language
                                                                                  {:count 1
                                                                                   :spec spec
                                                                                   :model small
                                                                                   }}]
                                                                                "es"))

                                                                     ;; TODO: move this to *before*
                                                                     ;; attempting generation that fails.
