{$q+,r+}

{Remove underscope before "graph" to disable graphics output}
{$define graph}

{Add underscope before "debug" to enable debug output}
{$define debug}

uses
    sysutils, math, graph, types, graphics;
const
    max_n = 30;
    eps = 1e-5;
    noAngle = 1e100;
    scale = 0.5;

type
    tarr = array [1..max_n] of longint;
    tarr2 = array [1..max_n] of double;

var
    i, j, n: longint;
    x, y: array[1..max_n] of longint;
    a: array [1..max_n] of double;
    clr: array[1..max_n] of tcolor;
    t: longint;
var
    _sc: longint;
    _sx, _sy, _sa1, _sa2: array [1..max_n * max_n] of double;
    _sclr: array [1..max_n * max_n] of tcolor;
    _angle2: double;

procedure addSector(c: tcolor; x, y, a1, a2: double);
begin
    inc(_sc);
    _sx[_sc] := x;
    _sy[_sc] := y;
    _sa1[_sc] := a1;
    _sa2[_sc] := a2;
    _sclr[_sc] := c;
end;

procedure drawPoints;
var
    i: longint;
    minx, maxx, miny, maxy: longint;
    sx, sy, cx, cy: double;
    sizex, sizey: integer;
    a1, a2: double;
    points: array [1..max_n, 1..5] of tPoint;     
    p2: array [1..max_n * max_n, 1..5] of tPoint;     
begin
    {$ifdef _graph}
    minx := maxlongint;
    maxx := -maxlongint;
    miny := maxlongint;
    maxy := -maxlongint;
    for i := 1 to n do begin
        if (minx > x[i]) then minx := x[i];
        if (maxx < x[i]) then maxx := x[i];
        if (miny > y[i]) then miny := y[i];
        if (maxy < y[i]) then maxy := y[i];
    end;

    sizex := form.clientwidth;
    sizey := form.clientheight;

    if maxx - minx = 0 then begin
        maxx := maxx + 1;
        minx := minx - 1;
    end;
    if maxy - miny = 0 then begin
        maxy := maxy + 1;
        miny := miny - 1;
    end;
    sx := sizex / (maxx - minx) * scale;
    sy := sizey / (maxy - miny) * scale;
    if sx > sy then begin
        sx := sy;
    end else begin
        sy := sx;
    end;
    cx := (maxx + minx) / 2;
    cy := (maxy + miny) / 2;

    clear;

    for i := 1 to n do begin
        points[i][1].x := round(sizex / 2 + sx * (x[i] - cx));
        points[i][1].y := round(sizey / 2 - sy * (y[i] - cy));
        if (a[i] < noAngle/10) then begin
            a1 := a[i] + _angle2;
            a2 := a[i] - _angle2;
            points[i][2].x := round(points[i][1].x + 5000 * cos(a1));
            points[i][2].y := round(points[i][1].y - 5000 * sin(a1));
            points[i][3].x := round(points[i][1].x + 5000 * cos((a1 + a2) / 2));
            points[i][3].y := round(points[i][1].y - 5000 * sin((a1 + a2) / 2));
            points[i][4].x := round(points[i][1].x + 5000 * cos(a2));
            points[i][4].y := round(points[i][1].y - 5000 * sin(a2));
            points[i][5].x := points[i][1].x;
            points[i][5].y := points[i][1].y;
        end else begin
            points[i][2].x := points[i][1].x;
            points[i][2].y := points[i][1].y;
            points[i][3].x := points[i][1].x;
            points[i][3].y := points[i][1].y;
            points[i][4].x := points[i][1].x;
            points[i][4].y := points[i][1].y;
            points[i][5].x := points[i][1].x;
            points[i][5].y := points[i][1].y;
        end;
    end;

    for i := 1 to _sc do begin
        p2[i][1].x := round(sizex / 2 + sx * (_sx[i] - cx));
        p2[i][1].y := round(sizey / 2 - sy * (_sy[i] - cy));
        a1 := _sa1[i];
        a2 := _sa2[i];
        p2[i][2].x := round(p2[i][1].x + 5000 * cos(a1));
        p2[i][2].y := round(p2[i][1].y - 5000 * sin(a1));
        p2[i][3].x := round(p2[i][1].x + 5000 * cos((a1 + a2) / 2));
        p2[i][3].y := round(p2[i][1].y - 5000 * sin((a1 + a2) / 2));
        p2[i][4].x := round(p2[i][1].x + 5000 * cos(a2));
        p2[i][4].y := round(p2[i][1].y - 5000 * sin(a2));
        p2[i][5].x := p2[i][1].x;
        p2[i][5].y := p2[i][1].y;
    end;

    canvas.pen.width := 1;
    canvas.brush.color := $3f3f3f;
    for i := 1 to n do begin
        canvas.polygon(points[i]);
    end;
    canvas.pen.color := 0;
    for i := 1 to n do begin
        canvas.polyline(points[i]);
    end;

    canvas.pen.width := 2;
    for i := 1 to n do begin
        canvas.pen.color := clr[i];    
        canvas.brush.color := clr[i];
        canvas.ellipse(points[i][1].x - 5, points[i][1].y - 5, points[i][1].x + 5, points[i][1].y + 5);
    end;

    for i := 1 to _sc do begin
        canvas.pen.color := _sclr[i];
        canvas.polyline(p2[i]);
    end;
    //waitForKey;
    {$endif}
end;

function norm(a: extended): extended;
begin
    while a > pi + eps do begin
        a := a - 2 * pi;
    end;
    while a < -(pi + eps) do begin
        a := a + 2 * pi;
    end;
    norm := a;
end;

function sortByAngle(n: longint; var v: tarr; var q: tarr2; cx, cy, a1, a2: double): boolean;
var
    f: boolean;
    t: longint;
    i, j: longint;
begin
    f := false;
    for i := 1 to n do begin
        if (abs(y[v[i]] - cy) > eps) or (abs(x[v[i]] - cx) > eps) then begin
            q[v[i]] := arctan2(y[v[i]] - cy, x[v[i]] - cx);
            while q[v[i]] < a1 - eps do begin
                q[v[i]] := q[v[i]] + 2 * pi;
            end;
            while q[v[i]] > a2 + eps do begin
                q[v[i]] := q[v[i]] - 2 * pi;
            end;
        end else begin
            f := true;
            q[v[i]] := 30 * pi;
        end;
    end;
    for i := 1 to n - 1 do begin
        for j := i + 1 to n do begin
            if q[v[i]] > q[v[j]] then begin
                t := v[i]; v[i] := v[j]; v[j] := t;
            end;
        end;
    end;
    sortByAngle := f;
end;

procedure light(v: tarr; n: longint; a1, a2: double);
var
    i, j: longint;
    l1, l2, tl1, tl2: double;
    cx, cy: double;    
    q: tarr2;
    da: double;
    v1, v2: tarr;
    f, uf: boolean;
    sc: longint;
    ac: double;
begin
    sc := _sc;
    if (n = 1) then begin
        addSector($ffcfcf, x[v[1]], y[v[1]], a1, a2);
        drawPoints;
        _sclr[_sc] := $cf0000;

        a[v[1]] := pi + (a1 + a2) / 2;
        while a[v[1]] > pi do begin
            a[v[1]] := a[v[1]] - 2 * pi;
        end;

        drawPoints;
    end else begin
        {$ifdef _debug}
        for i := low(clr) to high(clr) do begin
            clr[i] := $7f7f7f;
        end;
        writeln('v=');
        for i := 1 to n do begin
            writeln(v[i]);
            clr[v[i]] := $ff00ff;
        end;
        writeln;
        {$endif _debug}

        if abs(a2 - a1) < pi - eps then begin
            l1 := 1e100;
            l2 := 1e100;
            for i := 1 to n do begin
                tl1 := (cos(a2) * y[v[i]] - sin(a2) * x[v[i]]) / sin(a1 - a2);
                tl2 := (cos(a1) * y[v[i]] - sin(a1) * x[v[i]]) / sin(a2 - a1);
                if l1 > tl1 then begin
                    l1 := tl1;
                end;
                if l2 > tl2 then begin
                    l2 := tl2;
                end;
            end;
            cx := l1 * cos(a1) + l2 * cos(a2);
            cy := l1 * sin(a1) + l2 * sin(a2);
        end else begin            
            l1 := maxlongint;
            cx := 0;
            cy := 0;                
            ac := (a1 + a2) / 2;
            for i := 1 to n do begin
                tl1 := x[v[i]] * cos(ac) + y[v[i]] * sin(ac);
                if l1 > tl1 then begin
                    l1 := tl1;
                    cx := x[v[i]];
                    cy := y[v[i]];
                end;
            end;
        end;

        addSector($ff00ff, cx, cy, a1, a2);
        drawPoints;

        f := sortByAngle(n, v, q, cx, cy, a1, a2);

        j := 0;
        da := (a2 - a1) / n;
        uf := false;
        for i := 1 to n - 1 do begin            
            addSector($ffffff, cx, cy, a1 + i * da, a1);
            while q[v[j + 1]] < a1 + i * da - eps do begin
                addSector($ffff00, cx, cy, q[v[j + 1]], q[v[j + 1]]);
                inc(j);
            end;            
            while (j < i) and (q[v[j + 1]] < a1 + i * da + eps) do begin
                inc(j);
            end;
            if i = j then begin
                break;
            end;
            if f and (i = 1) then begin
                if j = 0 then begin
                    uf := true;
                    break;
                end;
            end;
        end;

        if not uf then begin
            for i := 1 to j do begin
                v1[i] := v[i];
            end;

            for i := j + 1 to n do begin
                v2[i - j] := v[i];
            end;
        end else begin
            v1[1] := v[n];
            for i := 1 to n - 1 do begin
                v2[i] := v[i];
            end;
            j := 1;
        end;

        addSector(clWhite, cx, cy, a1 + j * da, a1 + j * da);
        for i := 1 to j do begin
            clr[v1[i]] := $ffff00;
        end;
        for i := 1 to n - j do begin
            clr[v2[i]] := $00ffff;
        end;
        drawPoints;
        _sclr[_sc] := $cf0000;

        light(v1, j, a1, a1 + da * j);
        light(v2, n - j, a1 + da * j, a2);

        _sc := sc;
        addSector($0000ff, cx, cy, pi + a1, pi + a2);
        for i := 1 to n do begin
            clr[v[i]] := $0000ff;
        end;
        drawPoints;
        for i := 1 to n do begin
            clr[v[i]] := $ffffff;
        end;
    end;
    _sc := sc;
end;

function scalar(x1, y1, x2, y2: longint): double;
begin
    scalar := (x1 * x2 + y1 * y2) / sqrt(x1 * x1 + y1 * y1) / sqrt(x2 * x2 + y2 * y2);
end;

var
    sa1, sa2: double;
    mi, fv, cv, dx, dy: longint;
    mini, maxi: longint;
    minc, maxc, c: double;
    q: tarr2;
    v, v1, v2: tarr;
    z: double;
begin
    {$ifdef _graph}
    initGraph;
    {$endif}

    _sc := 0;

    read(n);
    for i := 1 to n do begin
        read(x[i], y[i]);
        v[i] := i;
        a[i] := noAngle;
    end;

    for i := 1 to n do begin
        for j := i + 1 to n do begin
            if (x[i] = x[j]) and (y[i] = y[j]) then begin
                writeln('incorrect');
                exit;
            end;
        end;
    end;

    _angle2 := pi / n;

    if n mod 2 = 0 then begin
        for i := 1 to n do begin
            for j := i + 1 to n do begin
                if (y[v[i]] > y[v[j]]) then begin
                    t := v[i]; v[i] := v[j]; v[j] := t;
                end;
            end;
        end;
        for i := 1 to n div 2 do begin
            v1[i] := v[i];
            v2[i] := v[i + n div 2];
            clr[v1[i]] := $ffff7f;
            clr[v2[i]] := $7fffff;
        end;
        addsector($ffffff, 0, (y[v[n div 2]] + y[v[n div 2 + 1]]) / 2, 0, pi);
        drawPoints;

        light(v1, n div 2, pi, 2 * pi);
        light(v2, n div 2, 0, pi);
    end else begin
        fv := 1;
        for i := 2 to n do begin
            if (y[fv] > y[i]) or (y[fv] = y[i]) and (x[fv] > x[i]) then begin
                fv := i;
            end;
        end;
        
        cv := fv;

        dx := 1;
        dy := 0;

        repeat 
            minc := maxlongint;
            maxc := -maxlongint;
            maxi := 0;
            mini := 0;
            for i := 1 to n do begin
                if (i <> cv) then begin
                    c := scalar(x[i] - x[cv], y[i] - y[cv], dx, dy);
                    if maxc < c then begin
                        maxc := c;
                        maxi := i;
                    end;
                    if minc > c then begin
                        minc := c;
                        mini := i;
                    end;
                end;
            end;

            if arccos(minc) - arccos(maxc) < pi * (n - 2) / n + eps then begin
                z := (arccos(minc) + arccos(maxc)) / 2 + arctan2(dy, dx);
                sortByAngle(n, v, q, x[cv], y[cv], z-pi, z+pi);
                for i := 1 to n div 2 do begin
                    v1[i] := v[i];
                    v2[i] := v[i + n div 2];
                    clr[v1[i]] := $ffff7f;
                    clr[v2[i]] := $7fffff;
                end;

                z := (q[v[n div 2 + 1]] + q[v[n div 2]]) / 2;
                addSector($ff00ff, x[cv], y[cv], z + pi / n, z + pi);
                addSector($ff00ff, x[cv], y[cv], z - pi / n, z - pi);
                addSector($0000ff, x[cv], y[cv], z, z + pi * (n - 1) / n);
                addSector($0000ff, x[cv], y[cv], z - pi * (n - 1) / n, z);
                addSector($ffffff, x[cv], y[cv], arccos(minc) + arctan2(dy, dx), arccos(maxc) + arctan2(dy, dx));
                drawPoints;

                light(v1, n div 2, z - pi * (n - 1) / n, z);
                light(v2, n div 2, z, z + pi * (n - 1) / n);
                a[cv] := z;

                drawPoints;
                break;
            end;

            dx := x[maxi] - x[cv];
            dy := y[maxi] - y[cv];
            cv := maxi;
        until fv = cv;
    end;

    for i := 1 to n do begin
        writeln(a[i]:0:10);
    end;
    
    
    {$ifdef _graph}
    _sc := 0;
    drawPoints;
    waitForKey();
    {$endif}
end.