           (recur datamap n (apply conj (rest continuations) new-conts))
           (recur datamap n (rest continuations))))))
 
-(defn dfs-begin
+(defn gen-next-info
+  [{:keys [counts end] :as datamap} {:keys [depth node edges]}]
+  (let [next-node (conj (vec (rest node)) (first edges))]
+    {:depth (inc depth)
+     :node next-node
+     :edges (->> (counts next-node)
+                 (pick-words))}))
+
+;; More true implementation of dfs
+(defn dfs-true
+  [{:keys [counts end] :as datamap} n stack]
+  (if-let [{:keys [depth node edges] :as node-info} (first stack)]
+    (cond
+      (and (= (+ depth (dec (count node))) n) ; TODO: lol
+           (end (last node)))
+        (reverse (map #(% :node) stack))
+      (or (= depth n) (empty? edges)) (recur datamap n (rest stack))
+      :else
+        (let [next-info (gen-next-info datamap node-info)
+              new-node-info (update-in node-info [:edges] rest)]
+          (recur datamap n (conj (cons new-node-info (rest stack)) next-info))))))
+
+(defn- dfs-true-begin
+  [{:keys [start counts] :as datamap} n]
+  {:pre [(pos? n)]}
+  (->> (pick-words start)
+       (map #(dfs-true datamap n [{:depth 0 :node % :edges (pick-words (counts %))}]))
+       (remove nil?)
+       (first)))
+
+(defn- dfs-begin
   [{:keys [start counts] :as datamap} n]
   {:pre [(pos? n)]}
   (->> (pick-words start)

         (concat (first coll))
         (reduce #(if (end %2) 
                      (str %1 %2)
                      (str %1 \space %2))))))
       (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)
