                                                                   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)))

                                                            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 [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
