                                                                                          {:comp {:synsem {:agr {:number number}}}})]
                                                                    (log/debug (str "generating from spec(2): " spec))
                                                                    (try
-                                                                     (process [{:fill-one-language
-                                                                                {:count 1
-                                                                                 :spec spec
-                                                                                 :model small
-                                                                                 }}]
-                                                                              "es")
+                                                                     (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.

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

                                                                         true
                                                                         (do

                                                       (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 (str "could not unify " spec " with person specification:" unify-with ".")]
                                                                 (if true
                                                                   (do
                                                                     (log/debug message)
                                                                     (log/debug (str "Ignoring and continuing."))
                                                                     unified)
                                                                   (do
                                                                     (log/error message)
