              (log/debug (str "parsing input: '" input "'"))
              ;; tokenize input (more than one tokenization is possible), and parse each tokenization.
              (let [tokenizations (filter #(not (empty? %)) (string/split input tokenizer))
-                   result (parse tokenizations model parse-with-truncate original-input)]
+                   result (parse tokenizations model
+                                 :parse-with-truncate parse-with-truncate
+                                 :original-input original-input)]
                (if (empty? result)
                  (log/warn (str "could not parse: \"" input "\". Tokenizations attempted: "
                                 (string/join ";" tokenizations)))

      (and (= :none (get-in tree [:head] :none))
           (= :none (get-in tree [:comp] :none))
           (not (= :none (get-in tree [:rule] :none))))
      (str "[" (get-in tree [:rule]) "/" cat
           pred
           " '" (fo tree) "']")

      (= head-first? :none)
      (str " '" (fo tree) "'/" cat
           pred)

      (= head-first? :comp)
      (str "[" (get-in tree [:rule]) " "

  "return a human-readable string of a phrase structure tree. leaves of the tree are printed
   by calling the supplied _fo_ function"
  (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])))
