                                                                   model)))
                                                   trees))]
                                        (if (not (empty? trees))
-                                         (log/debug (str "parse/parses: trees: "
+                                         (log/trace (str "parse/parses: trees: "
                                                          (string/join ","
                                                                       (map #(morph-ps %) trees))))
-                                         (log/debug (str "no trees found for left/right:")))
-                                       (log/debug (str " left: "
+                                         (log/trace (str "no trees found for left/right:")))
+                                       (log/trace (str " left: "
                                                        (string/join ","
                                                                     (map #(morph-ps %) left-signs))))
-                                       (log/debug (str " right: "
+                                       (log/trace (str " right: "
                                                        (string/join ","
                                                                     (map #(morph-ps %) right-signs))))
                                        (if parse-with-truncate truncated-trees trees)))

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

            (let [cache-value (get @lexical-cache k)]
              (if (= cache-value :none) nil
                  cache-value))))]
    (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
