const
  fin = 'kartice.in';
  fout = 'kartice.out';
  MaxN = 3000;


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

  PHashEntry = ^THashEntry;
  THashEntry = record
    v : TVector;
    count : Integer;
    next : PHashEntry;
  end;


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


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

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

  hash : array[0..HashSize-1] of PHashEntry;



  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;


  function Rem(a, b : Longint) : Longint;
  begin
    if a > 0 then
      Rem := a mod b
    else
    begin
      Rem := (-a) mod b;
      if Rem > 0 then
        Rem := b - Rem;
    end;
  end;


  procedure Insert(const t : TVector);
  var
    k : Longint;
    p : PHashEntry;
  begin
    k := (7333 * Rem(t.x, 98467) + 9839 * Rem(t.y, 89783)) mod hashSize;

    p := hash[k];
    while (p <> nil) and (Compare(p^.v, t) <> 0) do
      p := p^.next;

    if p = nil then
    begin
      p := New(PHashEntry);
      p^.count := 0;
      p^.v := t;
      p^.next := hash[k];
      hash[k] := p;
    end;

    inc(p^.count);
    if p^.count > max then
      max := p^.count;
  end;


  procedure Solve;
  var
    i, j : Integer;
    t, h : TVector;
    k : Longint;
  begin
    for k := 0 to hashSize - 1 do
      hash[k] := nil;

    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);

        Insert(t);
      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.
