type state = ON | OFF | DEAD

type peer = {
    i : int;

    descr : string;

    avail : float;
    mutable session : int;
    mutable day : bool;    
    mutable state : state;
    mutable real_avail : int;
    mutable real_decs : int;
  }

  
let _ = Random.self_init ()

  
module ChildrenArray : sig
    
    type t

    val length : t -> int
    val create : int -> t
    val mem : t -> int -> bool
    val add : t -> int -> unit
    val iteri : (int -> int -> unit) -> t -> unit
    val remove : t -> int -> unit
    val random : t -> int
    val clear : t -> unit
      
    val of_list : int list -> t
      
  end = struct

    type t = {
        mutable length : int; 
        array : int array;
      }
      
    let create n = {
        length = 0;
        array = Array.create n 0;
      }

    let clear t = t.length <- 0
      
    let add t i = 
      let len = t.length in
      t.array.(len) <- i;
      t.length <- len + 1

    let remove t pos =
      let tab = t.array in
      let len = t.length-1 in 
      tab.(pos) <- tab.(len);
      t.length <- len
    
    let length t = t.length

    let iteri f t =
      let rec iter i t =
        let len = t.length in
        if i < len then begin
            f i t.array.(i);
            if len > t.length then iter i t else
              iter (i+1) t
          end
      in
      iter 0 t

    let mem t v =     
      let rec iter i t =
        (i < t.length) &&
        (t.array.(i) = v || iter (i+1) t)
      in
      iter 0 t

    let random t =
       t.array.(Random.int t.length)

    let of_list list = 
      let array = Array.of_list list in
      {
        array = array;
        length = Array.length array;
      }
      
  end