 
     ;; for debugging, change (pmap) to (map) so logging is easier to read: in-order rather than interleaved by multiple workers.
     (.size (pmap (fn [verb]
-                   (log/trace (str "verb: " (strip-refs verb)))
+                   (log/debug (str "verb: " (strip-refs verb)))
                    (let [root-form (get-in verb [:espanol :espanol])]
                      (log/info (str "generating with verb: '" root-form "'"))
                      (.size (pmap (fn [tense]

                                                                   ))
                                                               [:sing :plur]))))
                                                     [:1st :2nd :3rd]))))
                                           (cond (or true (= tense
                                                             {:synsem {:sem {:aspect :perfect
                                                                             :tense :past}}}))

                                      (map (fn [gender]
                                             (let [spec (unify/unify spec
                                                                     {:comp {:synsem {:agr gender}}})]
                                               (log/debug (str "generating from gender: " gender))
                                               (.size
                                                (map (fn [person]
                                                       (let [debug (log/debug (str "generating from spec(pre-person):" spec))
                                                             unify-with {:comp {:synsem {:agr {:person person}}}}
                                                             unified (unify/unify spec unify-with)
                                                             
                                                             spec
                                                             (if (fail? unified)
                                                               (let [message
                                                                     (log/warn (str "could not unify " spec " with person specification:" unify-with "."))]
                                                                 (if true
                                                                   (do
                                                                     (log/warn message)
                                                                     (log/warn (str "Ignoring and continuing."))
                                                                     unified)
                                                                   (do
                                                                     (log/error message)
                                                                     (log/error "Stopping further processing now.")
                                                                     (throw (Exception. message)))))
                                                               unified)

                                                             ]
                                                         (log/debug (str "generating from person: " person))
                                                         (log/debug (str "generating from spec+person: " spec))
                                                         (.size
                                                          (map (fn [number]
                                                                 (let [debug (log/debug (str "generating from spec(1): " spec))
                                                                       spec (unify/unify spec
                                                                                         {:comp {:synsem {:agr {:number number}}}})]
                                                                   (log/debug (str "generating from spec(2): " spec))
                                                                   (try
                                                                     (process [{:fill-one-language
                                                                                {:count 1
