let module Vector = struct
  type t = {
    x : int;
        y : int
  }

  let to_string dst : string =
      (Printf.sprintf "{ x = %d ; y = %d }" dst.x dst.y)

  let create x y = 
    { x ; y }

  let equal dst src = 
      (dst.x = src.x) && (dst.y = src.y)
  
  let diff dst src =
    { x = (dst.x - src.x) ;
          y = (dst.y - src.y)
    }

  let mult src a =
    { x = src.x * a ;
          y = src.y * a 
    }

  let add dst src = 
    { x = (src.x + dst.x) ;
          y = (src.y + dst.y) 
    }

  let distance (dst:t) (src:t) = 
    (src.x - dst.x) * (src.x - dst.x) + (src.y - dst.y) * (src.y - dst.y)
    |> float_of_int
    |> sqrt
    |> int_of_float
  
  let is_capturable dst src = (distance dst src) < 220
    
    (*
  let is_near dst src = 
    (distance dst src) < (checkpoint_ray * 2)

  let is_far dst src = 
    ((distance dst src) >= checkpoint_ray * 6)
    *)
end in   

let module EntityCtx = struct

    type buster_state_t = 
        | Idle
        | Carrying of int
        
    type entity_t = {
        id : int ;
        pos : Vector.t ;
        pos_old : Vector.t ;
    }
    
    type ghost_t = {
        entity : entity_t ;
        hunters : int
    }
    
    type buster_t = {
        entity : entity_t ;
        state : buster_state_t ;
        team : int
    }
    
    type t = 
        | Buster of buster_t
        | Ghost of ghost_t

    let create entitytype entityid x y state value =
        let create_entity  entityid x y = { 
            id = entityid ;
            pos = Vector.create x y ;
            pos_old = Vector.create x y
        } in
        
        let create_ghost entity value = { entity ; hunters = value } in
        
        let create_buster entity state value =
            let state = match state with 
                | 0 -> Idle
                | _ -> Carrying value  
            in
            {
                entity ;
                state ;
                team = entitytype
            } 
        in
        
        (* common properties *)
        let entity = create_entity entityid x y in
        
        match entitytype with
        | -1 -> Ghost (create_ghost entity value)
        | _ -> Buster (create_buster entity state value)
            
end in


(* entityid: buster id or ghost id *)
(* y: position of this buster / ghost *)
(* entitytype: the team id if it is a buster, -1 if it is a ghost. *)
(* state: For busters: 0=idle, 1=carrying a ghost. *)
(* value: For busters: Ghost id being carried. For ghosts: number of busters attempting to trap this ghost. *)
let parse_entity () =         
    let line = input_line stdin in
    let parse_fn = (fun entityid x y entitytype state value -> 
        EntityCtx.create entitytype entityid x y state value) 
    in
    Scanf.sscanf line "%d %d %d %d %d %d" parse_fn
in

(* Send your busters out into the fog to trap ghosts and bring them home! *)

let bustersperplayer = int_of_string (input_line stdin) in (* the amount of busters you control *)
let ghostcount = int_of_string (input_line stdin) in (* the amount of ghosts on the map *)
let myteamid = int_of_string (input_line stdin) in (* if this is 0, your base is on the top left of the map, if it is one, on the bottom right *)

(* initialize buster ctx array *)

(* game loop *)
while true do
    let entities = int_of_string (input_line stdin) in (* the number of busters and ghosts visible to you *)
    for i = 0 to entities - 1 do        
        let entity = parse_entity () in
        ignore entity ;
    done;

    (* in buster id asc order *)
    for i = 0 to bustersperplayer - 1 do
        Printf.printf "MOVE 8000 4500\n%!" ; (* MOVE x y | BUST id | RELEASE *)
    done;

    ();
done;