{
    ACM ICPC 2003-2004 NEERC

    Problem:    Illumination
    Author:     Elena Andreeva
    Solution:   Andrew Stankevich
}

{$APPTYPE CONSOLE}
{$DEFINE ALLOWMULTITEST}
{$O-,Q+,R+}

program illumination;

uses
    math, sysutils;

const
    maxn = 30;
    eps = 1e-9;
    minc = -100;
    maxc = 100;

type
    tpoint = record
        x, y: extended;
    end;
    tsource = record
        x, y: extended;
        d: extended;
        i: longint;
        u: boolean;
    end;
    tsources = array [1..maxn] of tsource;

var
    n: longint;

{ Принимает сектор величины 2*pi*k/n и набор из k точек, лежащих в антисекторе. 
  Устанавливает направления для точек

  Предполагает:
  d2 = d1 + 2*pi*k/n
}
procedure ill(var p: tpoint; d1, d2: extended; k: longint; var s: tsources);
var
    p1, p2, pn: tpoint;
    v1, v2, an: array [1..maxn] of extended;
    i, j, m1, m2: longint;
    d, c1, c2: extended;
    tmp: tsource;
    s1: tsources;
    found: boolean;
begin
    assert(abs((d2 - d1) - 2 * pi * k / n) < eps);

    if k = 1 then
    begin
        s[1].d := (d1 + d2) / 2;
        exit;
    end;

    p1.x := cos(d1);
    p1.y := sin(d1);
    p2.x := cos(d2);
    p2.y := sin(d2);

    m1 := 1;
    m2 := 1;
    for i := 1 to k do
    begin
        v1[i] := (s[i].x - p.x) * p1.y - (s[i].y - p.y) * p1.x;
        v2[i] := - ((s[i].x - p.x) * p2.y - (s[i].y - p.y) * p2.x);

        if v1[i] < v1[m1] then
            m1 := i;
        if v2[i] < v2[m2] then
            m2 := i;
    end;

    assert(v1[m1] > -eps);
    assert(v2[m2] > -eps);

    d := p1.y * p2.x - p2.y * p1.x;
    if (abs(d) < eps) then
    begin
        assert(abs(v1[m1] - v2[m2]) < eps);

        pn.x := s[m1].x;
        pn.y := s[m1].y;
    end else begin
        c1 := v1[m1] + p.x * p1.y - p.y * p1.x;
        c2 := v2[m2] - p.x * p2.y + p.y * p2.x;

        pn.x := (c1 * p2.x + c2 * p1.x) / d;
        pn.y := (c2 * p1.y + c1 * p2.y) / d;
    end;

    for i := 1 to k do
    begin
        d := hypot(s[i].x - pn.x, s[i].y - pn.y);
        an[i] := p1.x * (s[i].x - pn.x) + p1.y * (s[i].y - pn.y);
        an[i] := -an[i];
        if abs(d) > eps then
        begin
            an[i] := an[i] / d;
            if an[i] > 1 then an[i] := 1;
            if an[i] < -1 then an[i] := -1;
            an[i] := arccos(an[i]) / (d2 - d1);
        end else begin
            an[i] := -100;
        end;
    end;

    for i := 1 to k do
    begin
        assert(((an[i] > -eps) and (an[i] < 1 + eps)) or (an[i] = -100));
    end;

    repeat
        for i := 1 to k do
            for j := i + 1 to k do
                if an[i] >an[j] then
                begin
                    tmp := s[i]; s[i] := s[j]; s[j] := tmp;
                    d := an[i]; an[i] := an[j]; an[j] := d;
                end;

        j := 1;
        found := false;
        for i := 1 to k - 1 do
        begin
            while (j < k) and (an[j + 1] < i / k + eps) do
                inc(j);
            if j = i then begin
                found := true;
                break;
            end;
        end;

        if not found then
        begin
            assert(an[1] = -100);
            an[1] := 100;
        end;
    until found;

    for i := 1 to j do
        s1[i] := s[i];
    ill(pn, d1, d1 + (d2 - d1) * j / k, j, s1);
    for i := 1 to j do
        s[i] := s1[i];

    for i := j + 1 to k do
        s1[i - j] := s[i];
    ill(pn, d1 + (d2 - d1) * j / k, d2, k - j, s1);
    for i := j + 1 to k do
        s[i] := s1[i - j];
end;

label
    success;

var
    p, p1: tsources;
    x, y: array [1..maxn] of longint;
    pt: tpoint;
    i, j, k, l: longint;
    tmp: tsource;
    pos, neg, uz: longint;
    flag: boolean;
    a, b, c, d, alpha: extended;

begin

    if eoln then runerror(239);
    read(n);
    if not eoln then runerror(239);
    readln;
    if (n < 3) or (n > maxn) then runerror(239);
    for i := 1 to n do
    begin
        if eoln then runerror(239);
        read(x[i]);
        if eoln then runerror(239);
        read(y[i]);
        if not eoln then runerror(239);
        readln;

        if (x[i] < minc) or (x[i] > maxc) or (y[i] < minc) or (y[i] > maxc) then runerror(239);
    end;
    {$IFNDEF ALLOWMULTITEST}
    if not eof then runerror(239);
    {$ENDIF}
    for i := 1 to n do
        for j := i + 1 to n do
            if (x[i] = x[j]) and (y[i] = y[j]) then
                runerror(239);

    for i := 1 to n do
    begin
        p[i].x := x[i];
        p[i].y := y[i];
        p[i].i := i;
    end;

    if n mod 2 = 0 then
    begin
        for i := 1 to n do
            for j := i + 1 to n do
                if p[i].y > p[j].y then
                begin
                    tmp := p[i]; p[i] := p[j]; p[j] := tmp;
                end;

        j := n div 2;

        pt.x := 0;
        pt.y := p[j].y;

        for i := 1 to j do
            p1[i] := p[i];
        ill(pt, 0, pi, j, p1);
        for i := 1 to j do
            p[i] := p1[i];

        for i := j + 1 to n do
            p1[i - j] := p[i];
        ill(pt, pi, 2 * pi, j, p1);
        for i := j + 1 to n do
            p[i] := p1[i - j];
    end else begin
        for i := 1 to n do
        begin
            for j := 1 to n do
            begin
                if i <> j then
                begin
                    a := p[i].y - p[j].y;
                    b := p[j].x - p[i].x;
                    c := a * p[i].x + b * p[i].y;

                    pos := 0;
                    neg := 0;
                    for k := 1 to n do
                    begin
                        d := a * p[k].x + b * p[k].y - c;
                        if d > eps then
                            inc(pos)
                        else if d < -eps then
                            inc(neg);
                    end;

                    if (pos <= (n div 2)) and (neg <= (n div 2)) then
                    begin
                        flag := true;
                        for k := 1 to n do
                            if k <> i then
                            begin
                                alpha := (p[k].x - p[i].x) * (p[j].x - p[i].x) + (p[k].y - p[i].y) * (p[j].y - p[i].y);
                                alpha := alpha / (hypot(p[k].x - p[i].x, p[k].y - p[i].y) * hypot(p[j].x - p[i].x, p[j].y - p[i].y));
                                if alpha > 1 then alpha := 1;
                                if alpha < -1 then alpha := -1;
                                alpha := arccos(alpha);
                                if abs(alpha - pi) < pi / n + eps then
                                begin
                                    flag := false;
                                    break;
                                end;
                            end;
                        if flag then begin
                            p[i].d := arctan2(p[j].y - p[i].y, p[j].x - p[i].x);

                            l := 0;
                            uz := 0;
                            for k := 1 to n do
                            begin
                                if (k <> i) then
                                begin
                                    d := a * p[k].x + b * p[k].y - c;
                                    if (d > 0) or ((abs(d) < eps) and (uz < n div 2 - pos)) then
                                    begin
                                        if abs(d) < eps then
                                            inc(uz);
                                        inc(l);
                                        p[k].u := true;
                                        p1[l] := p[k];
                                    end;
                                end;
                            end;
                            assert(l = n div 2);
                            pt.x := p[i].x;
                            pt.y := p[i].y;
                            ill(pt, p[i].d - pi, p[i].d - pi / n, n div 2, p1);
                            l := 0;
                            uz := 0;
                            for k := 1 to n do
                            begin
                                if (k <> i) then
                                begin
                                    d := a * p[k].x + b * p[k].y - c;
                                    if (d > 0) or ((abs(d) < eps) and (uz < n div 2 - pos)) then
                                    begin
                                        if abs(d) < eps then
                                            inc(uz);
                                        inc(l);
                                        p[k] := p1[l];
                                    end;
                                end;
                            end;

                            l := 0;
                            for k := 1 to n do
                            begin
                                if (k <> i) then
                                begin
                                    d := a * p[k].x + b * p[k].y - c;
                                    if ((d < 0) or (abs(d) < eps)) and (not p[k].u) then
                                    begin
                                        inc(l);
                                        p1[l] := p[k];
                                    end;
                                end;
                            end;
                            assert(l = n div 2);
                            pt.x := p[i].x;
                            pt.y := p[i].y;
                            ill(pt, p[i].d + pi / n, p[i].d + pi, n div 2, p1);
                            l := 0;
                            for k := 1 to n do
                            begin
                                if (k <> i) then
                                begin
                                    d := a * p[k].x + b * p[k].y - c;
                                    if ((d < 0) or (abs(d) < eps)) and (not p[k].u) then
                                    begin
                                        inc(l);
                                        p[k] := p1[l];
                                    end;
                                end;
                            end;

                            goto success;
                        end;
                    end;
                end;
            end;
        end;
        assert(false);

        success:
    end;

    for i := 1 to n do
        for j := i + 1 to n do
            if p[i].i > p[j].i then
            begin
                tmp := p[i]; p[i] := p[j]; p[j] := tmp;
            end;

    for i := 1 to n do
    begin
        assert(p[i].i = i);
        writeln(p[i].d :0 :15);
    end;
end.