#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;

#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()

namespace geom {
    
#define X real()
#define Y imag()
#define at(i) ((*this)[i])
#define EPS (1e-9)
#define PI (3.1415926535897932384626)
    
    typedef double R;
    typedef complex<R> P;
    
    inline int sgn(R a, R b = 0) { return a < b - EPS ? -1 : a > b + EPS ? 1 : 0; }
    inline bool near(P a, P b) { return !sgn(abs(a - b)); }
    inline R norm(const P &p) { return p.X * p.X + p.Y * p.Y; }
    inline R dot(const P &a, const P &b) { return real(a * conj(b)); }
    inline R cross(const P &a, const P &b) { return imag(conj(a) * b); }
    inline R sr(R a) { return sqrt(max(a, (R)0));}
    inline P unit(const P &p) { return p / abs(p); }
    inline P proj(const P &s, const P &t) { return t * dot(s, t) / norm(t);}
    
    struct L : public vector<P> { // line
        L() {}
        L(const P &a, const P &b) {
            this->push_back(a); this->push_back(b);
        }
        P dir() const { return at(1) - at(0); }
    };
    
    struct G : public vector<P> {
        G(int sz = 0) : vector(sz) {}
        L edge(int i) const { return L(at(i), at(i+1 == size() ? 0 : i+1)); }
    };
    
    //(a->b->c)
    int ccw(P a, P b, P c) {
        b -= a; c -= a;
        R cr = cross(b, c);
        if (sgn(cr) > 0) return 1;                 // counter clockwise
        if (sgn(cr) < 0) return -1;                // clockwise
        if (sgn(dot(b, c)) < 0) return 2;          // c--a--b on line
        if (sgn(norm(b), norm(c)) < 0) return -2;  // a--b--c on line
        return 0;
    }
    
    // L..line, S..segment, P..point
    
    bool intersectLL(const L &l, const L &m) {
        return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
        abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;   // same line
    }
    
    bool intersectLS(const L &l, const L &s) {
        return cross(l[1]-l[0], s[0]-l[0])*       // s[0] is left of l
        cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
    }
    
    bool intersectLP(const L &l, const P &p) {
        return abs(cross(l[1]-p, l[0]-p)) < EPS;
    }
    
    bool intersectSS(const L &s, const L &t) {
        return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
        ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
    }
    
    bool intersectSP(const L &s, const P &p) {
        return abs(cross(s[0]-s[1], s[0]-p)) < EPS && abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
    }
    
    inline P proj(const P &s, const L &t) { return t[0] + proj(s - t[0], t[1] - t[0]);}
    
    P projection(const L &l, const P &p) {
        R t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
        return l[0] + t*(l[0]-l[1]);
    }
    
    P reflection(const L &l, const P &p) {
        return p + (projection(l, p) - p) * (R)2;
    }
    
    R distanceLP(const L &l, const P &p) {
        return abs(p - projection(l, p));
    }
    
    R distanceLL(const L &l, const L &m) {
        return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
    }
    
    R distanceLS(const L &l, const L &s) {
        if (intersectLS(l, s)) return 0;
        return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
    }
    
    R distanceSP(const L &s, const P &p) {
        const P r = projection(s, p);
        if (intersectSP(s, r)) return abs(r - p);
        return min(abs(s[0] - p), abs(s[1] - p));
    }
    
    R distanceSS(const L &s, const L &t) {
        if (intersectSS(s, t)) return 0;
        return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
                   min(distanceSP(t, s[0]), distanceSP(t, s[1])));
    }
    
    P crosspoint(const L &l, const L &m) {
        R A = cross(l[1] - l[0], m[1] - m[0]);
        R B = cross(l[1] - l[0], l[1] - m[0]);
        if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
        if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
        return m[0] + B / A * (m[1] - m[0]);
    }
    
    struct C{P c; R r;};
    
    pair<P, P> crosspoint(C a, C b) {
        R d = abs(a.c - b.c);
        R l = ((a.r*a.r - b.r*b.r) / d + d) / 2.0;
        R h = sqrt(a.r*a.r - l*l);
        P e = a.c + (b.c-a.c) * l / d;
        P p = (b.c-a.c) * h / d * P(0,-1);
        return make_pair(e+p, e-p);
    }
    
    pair<P, P> crosspoint(C c, L l) {
	P p = projection(l, c.c);
	R d = abs(p - c.c);
	P ve = unit(l.dir());
	R w = sr(c.r * c.r - d * d);
	return mp(p - w * ve, p + w * ve);
    }

    R area(P a, P b, P c) { return imag(conj(b - a) * (c - a)) * 0.5; }
    
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
    
    R poly_area(const G& vec) {
        R ret = 0.0;
        rep(i, vec.size())
        ret += cross(curr(vec, i), next(vec, i));
        return fabs(ret) / (R)2;
    }
    
    //center of mass
    P center(const G &vec) {
        R ar = 0;
        P c(0, 0);
        rep(i, vec.size()) {
            P a = curr(vec,i), b = next(vec,i);
            R t = a.X * b.Y - b.X * a.Y;
            ar += t;
            c += (a + b) * t;
        }
        c /= 3 * ar;
        return c;
    }
   
    vector<pair<P, int>> convex_hull(G pl) {
        int n = pl.size(), k = 0;
        vector<pair<P, int>> ps;
        rep(i, pl.size()) {
        	ps.eb(pl[i], i);
        }
        sort(ALL(ps));
        
        vector<pair<P, int>> ch(2 * n);
        
        for (int i = 0; i < n; ch[k++] = ps[i++]) // lower-hull
            while (k >= 2 && ccw(ch[k-2].fi, ch[k-1].fi, ps[i].fi) != 1) --k;
        for (int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--]) // upper-hull
            while (k >= t && ccw(ch[k-2].fi, ch[k-1].fi, ps[i].fi) != 1) --k;
        ch.resize(k-1);
        return ch;
    }

}

using namespace geom;

namespace std {
    bool operator<(const P &a, const P &b) { return sgn(a.X - b.X) ? a.X < b.X : a.Y < b.Y; }
    istream& operator>>(istream &is, P &p) { R x, y; is >> x >> y; p = P(x, y); return is; }
}

G pl;
int N;
ll x[110], y[110];
R ang[110];

int main() {
	cin >> N;

	rep(i, N) {
		cin >> x[i] >> y[i];
		pl.pb(P(x[i], y[i]));
	}

	auto res = convex_hull(pl);

	int sz = res.size();

	R sum = 0.0;
	rep(i, sz) {
		int j = i-1;
		if (j < 0) j += sz;
		int k = i+1;
		if (k >= sz) k -= sz;
		P v = (res[j].fi-res[i].fi)/(res[k].fi-res[i].fi);
		R t = PI - arg(v);
		ang[res[i].se] = t;
		sum += t;
	}

	rep(i, N) {
		printf("%.8f\n", ang[i] / sum);
	}

	return 0;
}

Measured memory_bytes: 256