        (first)))
 
 ;; Tail-recursive
-(defn dive
+(defn- dive
   [state {:keys [counts] :as datamap} n depth cont]
   (if (>= (+ depth (count state)) n)
       (conj cont state)
       (let [result (conj (vec (rest state)) (pick-word (counts state)))]
         (recur result datamap n (inc depth) (conj cont state)))))
 
-(defn dfs-single
+(defn- dfs-single
   [{:keys [start counts] :as datamap} n]
   {:pre [(pos? n)]}
+  (prn "Diving!")
   (dive (pick-word start) datamap n 0 []))
 
 (defn gen-sentence

         (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)
