     (apply min (filter (comp not nil?)
                        indices))))
 
-(defn only-non-unknown-columns [{:keys [maze player] :as labyrinth}]
-  (p :only-non-unknown-columns
-     (let [row-cells (map :cells maze)
-           row-length (count (first row-cells))
-           earliest-column (first-non-unknown-index row-cells)
-           latest-column (first-non-unknown-index (map reverse row-cells))
-           new-maze (map (fn [row]
-                           (update-in row [:cells]
-                                      #(vec (take (- row-length
-                                                     latest-column
-                                                     earliest-column)
-                                                  (drop earliest-column %)))))
-                         maze)
-           new-player (update-in player [:x] - earliest-column)]
-       (-> labyrinth
-           (assoc :maze new-maze)
-           (assoc :player new-player)))))
-
-(defn compress-labyrinth [labyrinth]
-  (p :compress-labyrinth
-     (->> labyrinth
-          non-unknown-rows
-          only-non-unknown-columns)))
+(defnp only-non-unknown-columns [{:keys [maze player] :as labyrinth}]
+  (let [row-cells (map :cells maze)
+        row-length (count (first row-cells))
+        earliest-column (first-non-unknown-index row-cells)
+        latest-column (first-non-unknown-index (map reverse row-cells))
+        new-maze (map (fn [row]
+                        (update-in row [:cells]
+                                   #(vec (take (- row-length
+                                                  latest-column
+                                                  earliest-column)
+                                               (drop earliest-column %)))))
+                      maze)
+        new-player (update-in player [:x] - earliest-column)]
+    (-> labyrinth
+        (assoc :maze new-maze)
+        (assoc :player new-player))))
+
+(defnp compress-labyrinth [labyrinth]
+  (->> labyrinth
+       non-unknown-rows
+       only-non-unknown-columns))
 
 (defn render-labyrinth
   "Render a debug version of the labyrinth. Draws the player and all

    :wall "⎕"
    :empty " "))

(defn non-unknown-rows [{:keys [maze] :as labyrinth}]
  (p :non-unknown-rows
     (let [new-maze (vec (filter :row-has-wall maze))]
       (assoc labyrinth :maze new-maze))))

(defn get-cells-with-coordinates [maze]
  (for [[row-index row] (map vector (range) maze)

      turn-player-right
      mark-unknown-as-empty-at-player-left))

(defnp move-route-and-back [{:keys [forward backward]}]
  (-> (create-unsolved-labyrinth (longest forward backward))
      (move-route forward)
      turn-around-at-end-of-labyrinth
      (move-route backward)))

(defn get-rooms [maze]
  (->> (get-cells-with-coordinates maze)
