                 (not (= :verb (get-in % [:synsem :cat])))))
    (map
     (fn [lexeme]
-      (do
+      (let [result (unify lexeme spec)]
         (log/debug (str "get-lexemes: testing lexeme: "
-                        (dag_unify.core/strip-refs lexeme)))
-        (let [result (unify lexeme spec)]
-          (if (= result :fail)
-            (log/debug (str "fail-path:"
-                            (dag_unify.core/fail-path lexeme spec))))
-          result))))
+                        "'" ((:morph model) lexeme) "'"
+                        (str " " 
+                             (if (= result :fail)
+                               (let [fail-path
+                                     (dag_unify.core/fail-path lexeme spec)]
+                                 {:fail-path (:fail-path fail-path)
+                                  :lexeme (:val1 fail-path)
+                                  :spec (:val2 fail-path)})
+                               "ok."))))
+        result)))
    (filter #(not (= :fail %)))))
 
 (defn show-spec [spec]

(def ^:const shufflefn
  (fn [x]
    ;; deterministic generation:
;;    x
    ;; nondeterministic generation
    (lazy-seq (shuffle x))

    ))

(declare add-comp-to-bolts)
(declare add-comps-to-bolt)

                       (assoc-in candidate-parent [:head] head))))
           (lightning-bolts model spec depth max-depth (rest candidate-parents))))
        []))
    (let [lexemes (shufflefn (get-lexemes model spec))]
      (if (empty? lexemes)
        (log/debug (str "lightning-bolts: no lexemes at depth: " depth
                        " for spec: " (dag_unify.core/strip-refs spec)))
        (log/debug (str "lightning-bolts at depth: " depth
                        " first lexeme:" "'"
                        ((:morph model) (first lexemes))
                        "'")))
      lexemes)))

(defn add-comps-to-bolt
