       (or (end (last node)) (= 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)
-       (map #(dfs-cont datamap n [{:queue [] :state % :depth 0}]))
-       (remove nil?)
-       (first)))
-
-(defn gen-next-dive
-  [{:keys [counts end] :as datamap} {:keys [depth node edges]}]
-  (let [next-node (conj (vec (rest node)) (first edges))]
-    {:depth (if (end (first edges)) depth (inc depth))
-     :node next-node
-     :edges (pick-words (counts next-node))}))
+        (let [next-info (gen-next-frame true datamap node-info)
+              new-node-info (update-in node-info [:edges] rest)
+              next-stack (conj (cons new-node-info (rest stack)) next-info)]
+          (recur datamap n next-stack)))))
 
 (defn- dive
+  "Runs a dfs, with no punctuation constraints."
   [{:keys [counts end] :as datamap} n stack]
   (if-let [{:keys [depth node edges] :as node-info} (first stack)]
     (cond

  [seed & code]
  `(binding [*rnd* (java.util.Random. ~seed)]
    ~@code))

(defn- pick-word
  "Takes a map of counts in the form of {'sad' 2, 'mad' 3} (values from the 

; text will be less than fifty words.
;   I will do the former.

;;; -----=====##### CONCERNING 153 #####=====-----
;   Watching what's happening using the true-dfs code is quite interesting. One
; thing that could be improved is predicting end branches. That is, if a node
