   the entire tree costs about 20% time than truncating it."
   ([input model & {:keys [parse-with-truncate original-input]}]
    (let [parse-with-truncate
-         (cond (= parse-with-truncate false)
+         (cond true false (= parse-with-truncate false)
                false
                true true)
          original-input (if original-input original-input input)

                                                              (lookup model string))
                                                            right-strings)
                                      left-signs (lazy-cat left-lexemes (filter map? left))
                                      right-signs (lazy-cat right-lexemes (filter map? right))
                                      ]
                                  (lazy-cat
                                   (if (and (not (empty? left-signs))
                                            (not (empty? right-signs)))

(defn lookup [{lookup :lookup
               lexical-cache :lexical-cache
               default-fn :default-fn} k]
  (let [pre-default
        (if (or (= false parse-with-lexical-caching)
                (nil? lexical-cache))
