                 unit (Unit. unit-id unit-type player-id mass radius x y vx vy extra extra2)]
             (swap! units conj unit)
             (recur (dec i)))))
-      (let [wrecks (filter #(= (:unit-type %) 4) @units)
+      (let [wrecks (filter #(= (:unit-type %) :wreck) @units)
             wrecks-with-water (filter #(> (:extra %) 0) wrecks)
-            mobile-units (filter #(= (:unit-type %) 0) @units)
-            enemy-mobile-units (filter #(not= (:player-id %) 0) mobile-units)
-            my-unit (first (filter #(= (:player-id %) 0) mobile-units))
-            next-wreck (first (sort-by #(distance (:x my-unit) (:y my-unit) (:x %) (:y %)) wrecks-with-water))]
+            tankers (filter #(= (:unit-type %) :tanker) @units)
+            reapers (filter #(= (:unit-type %) :reaper) @units)
+            destroyers (filter #(= (:unit-type %) :destroyer) @units)
+            enemy-reapers (filter #(not= (:player-id %) 0) reapers)
+            enemy-destroyers (filter #(not= (:player-id %) 0) destroyers)
+            my-reaper (first (filter #(= (:player-id %) 0) reapers))
+            my-destroyer (first (filter #(= (:player-id %) 0) destroyers))
+            next-wreck (first (sort-by #(distance (:x my-reaper) (:y my-reaper) (:x %) (:y %)) wrecks-with-water))
+            next-tanker (first (sort-by #(distance (:x my-destroyer) (:y my-destroyer) (:x %) (:y %)) tankers))]
         (binding [*out* *err*] (println "wrecks : " (string/join " " (map #(into {} %) wrecks)))
-                               (println "mobile-units : " (string/join " " (map #(into {} %) mobile-units)))
-                               (println "enemy-mobile-units : " (string/join " " (map #(into {} %) enemy-mobile-units)))
-                               (println "my-unit : " (string/join " " my-unit))
-                               (println "next-wreck : " (string/join " " next-wreck)))
-        (println (compute-action my-unit next-wreck))
-        (println "WAIT")
+                               (println "wrecks with water: " (string/join " " (map #(into {} %) wrecks-with-water)))
+                               (println "tankers : " (string/join " " (map #(into {} %) tankers)))
+                               (println "reapers : " (string/join " " (map #(into {} %) reapers)))
+                               (println "destroyers : " (string/join " " (map #(into {} %) destroyers)))
+                               (println "enemy reapers: " (string/join " " (map #(into {} %) enemy-reapers)))
+                               (println "enemy destroyers: " (string/join " " (map #(into {} %) enemy-destroyers)))
+                               (println "my reaper : " (string/join " " my-reaper))
+                               (println "my-destroyer : " (string/join " " my-destroyer))
+                               (println "next-wreck : " (string/join " " next-wreck))
+                               (println "next-tanker : " (string/join " " next-tanker)))
+        (println (compute-reaper-action my-reaper next-wreck))
+        (println (compute-destroyer-action my-destroyer next-tanker))
         (println "WAIT")))))
 
       ; (binding [*out* *err*]

  "Test whether 'my-unit' is 'in' the 'other-unit'"
  (< (distance (:x my-unit) (:y my-unit) (:x other-unit) (:y other-unit)) (:radius other-unit)))

(defn compute-action [my-unit next-wreck]
  (cond
    (in my-unit next-wreck) "WAIT"
    true (str (:x next-wreck) " " (:y next-wreck) " 150")))

(defn -main [& args]
  (while true

; the standard input according to the problem statement.

(require '[clojure.string :as string])

;;unitType 0 (Reaper), 1 (Destroyer), 3 (Tanker), 4 (Wreck)
(def unit-types [:reaper :destroyer :placeholder :tanker :wreck])

(defrecord Unit
  [unit-id unit-type player-id mass radius x y vx vy extra extra2])
