             (let [cache-value (get @lexical-cache k)]
               (if (= cache-value :none) nil
                   cache-value))))]
-    (log/debug (str "default-fn: nil? " (nil? default-fn)))
-    (log/debug (str "pre-default: count: " (count pre-default)))
+    (log/trace (str "default-fn: nil? " (nil? default-fn)))
+    (log/trace (str "pre-default: count: " (count pre-default)))
     (cond (nil? default-fn)
           pre-default
           true

                                                            right-strings)
                                      left-signs (lazy-cat left-lexemes (filter map? left))
                                      right-signs (lazy-cat right-lexemes (filter map? right))
                                      debug (if (not (empty? left-lexemes))
                                              (log/debug (str "#lexemes found for left:'" (string/join "','" left-strings) "':"
                                                              (count left-lexemes))))
                                      debug (if (not (empty? right-lexemes))
                                              (log/debug (str "#lexemes found for right:'" (string/join "','" right-strings) "':"
                                                              (count right-lexemes))))
                                      ]
                                  (lazy-cat
                                   (if (and (not (empty? left-signs))

  (let [head-first? (get-in tree [:first] :none)
        cat (str (get-in tree [:synsem :cat]) "")]
    (if (= true (get-in tree [:phrasal]))
      (do (log/trace (str "fo-ps: rule at top of tree: " (get-in tree [:rule])))
          (log/trace (str "fo-ps: " (strip-refs tree))))
      (log/trace (str "fo-ps: leaf: " (strip-refs tree))))
    (cond
      (and (= :none (get-in tree [:head] :none))
           (= :none (get-in tree [:comp] :none))
