const
  fin = 'kartice.in';
  fout = 'kartice.out';
  MaxN = 3000;
  MaxM = (MaxN * (MaxN - 1)) DIV 2;


type
  TVector = record
    x, y : Longint;
  end;

  TListEntry = record
    v : TVector;
    count : Integer;
  end;


const
  zero : TVector = (x : 0; y : 0);


var
  n : Integer;
  p : array[1..MaxN] of TVector;

  max : Integer;
  sol : array[1..MaxN] of Integer;

  m : Longint;
  list : array[1..MaxM] of TListEntry;



  function Compare(const a, b : TVector) : Longint;
  begin
    Compare := a.x - b.x;
    if Compare = 0 then
      Compare := a.y - b.y;
  end;


  function Sub(const a, b : TVector) : TVector;
  begin
    Sub.x := a.x - b.x;
    Sub.y := a.y - b.y;
  end;


  procedure QuickSort;
  var
    p : TVector;
    tmp : TListEntry;

    procedure Sort(l, r : Longint);
    var
      i, j : Longint;
    begin
      i := l;
      j := r;
      p := list[(l + r) DIV 2].v;

      repeat
        while Compare(list[i].v, p) < 0 do inc(i);
        while Compare(list[j].v, p) > 0 do dec(j);
        if i <= j then
        begin
          tmp := list[i];
          list[i] := list[j];
          list[j] := tmp;
          inc(i);
          dec(j);
        end;
      until i > j;

      if (l < j) then Sort(l, j);
      if (i < r) then Sort(i, r);
    end;

  begin
    Sort(1, m);
  end;


  procedure Solve;
  var
    i, j : Integer;
    t : TVector;
    k, l : Longint;
    a, b, mid : Longint;
    c : Longint;
    found : Boolean;
  begin
    m := 0;

    for i := 1 to n - 1 do
      for j := i + 1 to n do
      begin
        t := Sub(p[i], p[j]);
        if Compare(t, zero) < 0 then
          t := Sub(zero, t);

        inc(m);
        list[m].v := t;
        list[m].count := 0;
      end;

    QuickSort;

    l := 1;

    for k := 2 to m do
      if Compare(list[k].v, list[l].v) <> 0 then
      begin
        inc(l);
        list[l] := list[k];
      end;

    max := 0;

    for i := 1 to n do
    begin
      for j := 1 to i-1 do
      begin
        t := Sub(p[i], p[j]);
        if Compare(t, zero) < 0 then
          t := Sub(zero, t);

        a := 1;
        b := l;

        found := false;
        while not found do
        begin
          mid := (a + b) div 2;

          c := Compare(list[mid].v, t);
          if c < 0 then
            a := mid + 1
          else
            if c > 0 then
              b := mid - 1
            else
              found := true;
        end;

        inc(list[mid].count);
        if list[mid].count > max then
          max := list[mid].count;
      end;
      sol[i] := max;
    end;
  end;


  procedure ReadInput;
  var
    f : Text;
    i : Integer;
  begin
    Assign(f, fin);
    Reset(f);
    Readln(f, n);
    for i := 1 to n do
      Readln(f, p[i].x, p[i].y);
    Close(f);
  end;


  procedure WriteOutput;
  var
    f : Text;
    i : Integer;
  begin
    Assign(f, fout);
    Rewrite(f);
    for i := 1 to n do
      Writeln(f, sol[i]);
    Close(f);
  end;



begin
  ReadInput;
  Solve;
  WriteOutput;
end.
