   (some (partial winning-by? player) (all-lines board) ))
 
 (defn evaluate-board [board player]
-  (do (prn (str "Player: " (winning? board player)  "  Opponent:" (winning? board (opponent player))))
-      (cond (winning? board player) 1 
-            (winning? board (opponent player)) -1
-            (draw? board) 0 
-            :else nil)))
+  (cond (winning? board player) 1 
+        (winning? board (opponent player)) -1
+        (draw? board) 0 
+        :else nil))
 
 (defn evaluate-moves-deep [board player max-depth computer & last-move]
   (let [score (evaluate-board board computer)]

              evaluated-moves (map #(hash-map :score ((trampoline evaluate-moves-deep (% :board) (opponent player) 
                                                                 (dec max-depth) computer (% :move)) :score ) 
                                              :move (% :move)) legal-moves  )]
          (do (prn player "++" computer "-- " max-depth "~>" (sort-by :score > evaluated-moves))
              (prn player "++" computer "-- " max-depth "~<" (sort-by :score < evaluated-moves))
              (prn "~~~~~~~~~" legal-moves)
            (first (if (= player computer) 
                     (sort-by :score > evaluated-moves)
                     (sort-by :score < evaluated-moves))))))))

(defn find-best-move [board]
  ((evaluate-moves-deep board "O" 3 "O") :move ))

               ["O" "B" "O"]]
        result (evaluate-moves-deep board "O" 1 "O")
        move (result :move)]
    (is (= move [2 1] )  )))

(deftest block-one-move-win
  (let [board [["X" "B" "B"] 
