          (concat (first coll))
          (reduce #(if (end %2) 
                       (str %1 %2)
-                      (str %1 \space %2))))))+                      (str %1 \space %2))))))
+
+(defn gen-sentence-true-dfs
+  [{:keys [end] :as datamap} n]
+  {:pre [(pos? n)]}
+  (let [coll (if-let [s (dfs-true-begin datamap n)] s (dfs-single datamap n))]
+    (->> coll
+         (rest)
+         (map last)
+         (concat (first coll))
+         (reduce #(if (end %2) 
+                      (str %1 %2)
+                      (str %1 \space %2))))))
+
+(def map-loc "resources/public/corpora/loremipsum/2.json")
+(use 'wysitutwyg.markov.textgen)
+(def dmap (read-into-datamap map-loc))
+
+;; TODO: Okay, it doesn't generate the currect length if you have 2-tuples.
+;; I thought I fixed that, but I didn't.
+;; This is why tests are good.
+
+(defn test-both [n]
+  (do
+    (prn "LENGTH: " n)
+    (binding [*rnd* (java.util.Random. 1)]
+      (prn "Psdo: " (gen-sentence dmap n)))
+    (binding [*rnd* (java.util.Random. 1)]
+      (prn "True: " (gen-sentence-true-dfs dmap n)))))
+
+; (test-both 2)
+(test-both 10) ; lol that tricked me into thinking it was length 9!
+;;; TODO: Issue: punctuation has its own depth in dives
+(test-both 20)
+(test-both 40) ;; Issue: 39 not 40!
+(test-both 30) ;; Issue: 39 not 40!
+
+#_(binding [*rnd* (java.util.Random. 1)]
+  (prn (gen-sentence dmap 500)))
+
+#_(binding [*rnd* (java.util.Random. 1)]
+  (prn (gen-sentence-true-dfs dmap 500)))
            (nth keys i)
            (recur (inc i) (+ (counts i) sum)))))))

(defn pick-words
  "Returns a lazy sequence of the next states from the start state, generated
  by repeatedly picking words."
  [counts]

       (map #(hash-map :depth (inc depth)
                       :queue (conj queue state)
                       :state %1))))

;; cont consists of: {:depth depth, :queue string, :state state}
;;   Works for 2-3 tuples with caveats - many fewer viable paths, so drops to
;; dive a lot more! Also - it has n too many words, where n is one less than
;; the size of the tuple.
(defn- dfs-cont
  [{:keys [counts end] :as datamap} n continuations]
  (if-let [{:keys [depth queue state] :as cont} (first continuations)]
    (if (>= (+ depth (count state)) n)
