#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#include<iostream>
#include<unordered_set>

using namespace std;

#define dprint(Exp,...) if(Exp){fprintf(stderr, __VA_ARGS__);}
#define printe(...) fprintf(stderr, __VA_ARGS__);
#define PrtExp(_Exp)  cerr<< #_Exp <<" = "<< (_Exp)
#define PrtExpN(_Exp)  cerr<< #_Exp <<" = "<< (_Exp) <<"\n"

#define SINT(n) scanf("%d",&n)
#define SINT2(n,m) scanf("%d %d",&n,&m)
#define SINT3(n,m,o) scanf("%d %d %d",&n,&m,&o)
#define SINT4(n,m,o,P) scanf("%d %d %d %d",&n,&m,&o,&P)
#define SINT5(n,m,o,P,q) scanf("%d %d %d %d %d",&n,&m,&o,&P,&q)
#define SLL(n) scanf("%lld",&n)
#define SLL2(n,m) scanf("%lld %lld",&n,&m)
#define SLL3(n,m,o) scanf("%lld %lld %lld",&n,&m,&o)
#define SST(s) scanf("%s",s)
#define SCH(c) scanf("%c",&c)

#define GC() getchar()

#define PINT(n) printf("%d",(int)(n))
#define PINT2(n,m) printf("%d %d",(int)(n),(int)(m))
#define PINT3(n,m,l) printf("%d %d %d",(int)(n),(int)(m),(int)(l))
#define PLL(n) printf("%lld",(long long)(n))
#define PST(s) printf("%s",(s))
#define PCH(s) printf("%c",(s))

#define PINTN(n) printf("%d\n",(int)(n))
#define PINT2N(n,m) printf("%d %d\n",(int)(n),(int)(m))
#define PINT3N(n,m,l) printf("%d %d %d\n",(int)(n),(int)(m),(int)(l))
#define PLLN(n) printf("%lld\n",(long long)(n))
#define PSTN(s) printf("%s\n",(s))
#define PCHN(s) printf("%c\n",(s))

#define PSP() printf(" ")
#define PN() printf("\n")

#define PC(c) putchar(c)
#define CSP (' ')
#define SN ("\n")

#define rep(i,a) for(int i=0;i<a;i++)
#define reP(i,a) for(int i=0;i<=a;i++)
#define Rep(i,a) for(int i=a-1;i>=0;i--)
#define ReP(i,a) for(int i=a;i>=0;i--)

#define rEp(i,a) for(i=0;i<a;i++)
#define rEP(i,a) for(i=0;i<=a;i++)
#define REp(i,a) for(i=a-1;i>=0;i--)
#define REP(i,a) for(i=a;i>=0;i--)

#define repft(i,a,b) for(int i=a;i<b;i++)
#define repfT(i,a,b) for(int i=a;i<=b;i++)
#define Repft(i,a,b) for(int i=a-1;i>=b;i--)
#define RepfT(i,a,b) for(int i=a;i>=b;i--)

#define foreach(a,it) for(auto it = a.begin(); it != a.end(); ++it)

#define FILL(a,v) fill(begin(a),end(a), v)
#define FILL0(a) memset(a,0,sizeof(a))
#define FILL1(a) memset(a,-1,sizeof(a))

typedef long long ll;

typedef unsigned long long ull;
typedef pair<int, int> Pi;
typedef pair<ll, ll>   Pll;


const int INF = 1010000000; // 0x3C33'6080
const ll INFLL = 0x1f1f1f1f1f1f1f1fLL;//2,242,545,357,980,376,863

template <class A, class B> inline ostream& operator<<(ostream& st, const pair<A, B>& P) { return st << "(" << P.first << "," << P.second << ")"; };
template <class A, class B> inline pair<A, B> operator+(const pair<A, B>& P, const pair<A, B>& Q) { return pair<A, B>(P.first + Q.first, P.second + Q.second); };
template <class A, class B> inline pair<A, B> operator-(const pair<A, B>& P, const pair<A, B>& Q) { return pair<A, B>(P.first - Q.first, P.second - Q.second); };

#define fs  first
#define sc  second



using ld = long double;
using P = std::complex<ld>;
using G = std::vector<P>;
const ld pi = std::acos(-1);
const ld eps = 1e-10;
const ld inf = 1e12;

ld cross(const P &a, const P &b) { return a.real() * b.imag() - a.imag() * b.real(); }
ld dot(const P &a, const P &b) { return a.real() * b.real() + a.imag() * b.imag(); }

/*
CCW

-- BEHIND -- [a -- ON -- b] --- FRONT --

CW
*/
enum CCW_RESULT { CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0 };
int ccw(P a, P b, P c) {
	b -= a;
	c -= a;
	if (cross(b, c) > eps) return CCW;    // counter clockwise
	if (cross(b, c) < -eps) return CW;    // clockwise
	if (dot(b, c) < 0) return BEHIND;     // c--a--b on line
	if (norm(b) < norm(c)) return FRONT;  // a--b--c on line
	return ON;
}

namespace std {
	bool operator<(const P &a, const P &b) {
		return std::abs(real(a) - real(b)) > eps ? real(a) < real(b) : imag(a) < imag(b);
	}
}

struct L : public std::vector<P> {
	L(const P &a = P(), const P &b = P()) : std::vector<P>(2) {
		begin()[0] = a;
		begin()[1] = b;
	}

	// Ax + By + C = 0
	L(ld A, ld B, ld C) {
		if (std::abs(A) < eps && std::abs(B) < eps) {
			abort();
		} else if (std::abs(A) < eps) {
			*this = L(P(0, -C / B), P(1, -C / B));
		} else if (std::abs(B) < eps) {
			*this = L(P(-C / A, 0), P(-C / A, 1));
		} else {
			*this = L(P(0, -C / B), P(-C / A, 0));
		}
	}
};

struct C {
	P p;
	ld r;
	C(const P &p = 0, ld r = 0) : p(p), r(r) {}
};

bool intersectLL(const L &l, const L &m) {
	return std::abs(cross(l[1] - l[0], m[1] - m[0])) > eps ||  // non-parallel
		std::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 std::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 std::abs(s[0] - p) + std::abs(s[1] - p) - std::abs(s[1] - s[0]) <
		eps;  // triangle inequality
}

P projection(const L &l, const P &p) {
	ld 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 + (ld)2 * (projection(l, p) - p); }
ld distanceLP(const L &l, const P &p) { return std::abs(p - projection(l, p)); }
ld distanceLL(const L &l, const L &m) { return intersectLL(l, m) ? 0 : distanceLP(l, m[0]); }
ld distanceLS(const L &l, const L &s) {
	if (intersectLS(l, s)) return 0;
	return std::min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
ld distanceSP(const L &s, const P &p) {
	const P r = projection(s, p);
	if (intersectSP(s, r)) return std::abs(r - p);
	return std::min(std::abs(s[0] - p), std::abs(s[1] - p));
}
ld distanceSS(const L &s, const L &t) {
	if (intersectSS(s, t)) return 0;
	return std::min(std::min(distanceSP(s, t[0]), distanceSP(s, t[1])),
		std::min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspointLL(const L &l, const L &m) {
	ld A = cross(l[1] - l[0], m[1] - m[0]);
	ld B = cross(l[1] - l[0], l[1] - m[0]);
	if (std::abs(A) < eps && std::abs(B) < eps) return m[0];  // same line
	if (std::abs(A) < eps) assert(false);                     // !!!PRECONDITION NOT SATISFIED!!!
	return m[0] + B / A * (m[1] - m[0]);
}

G andrewScan(G ps) {
	int N = ps.size(), k = 0;
	std::sort(ps.begin(), ps.end());
	G res(N * 2);
	for (int i = 0; i < N; i++) {
		while (k >= 2 && ccw(res[k - 2], res[k - 1], ps[i]) == CW) k--;
		res[k++] = ps[i];
	}
	int t = k + 1;
	for (int i = N - 2; i >= 0; i--) {
		while (k >= t && ccw(res[k - 2], res[k - 1], ps[i]) == CW) k--;
		res[k++] = ps[i];
	}
	res.resize(k - 1);
	return res;
}

pair<P, double> in[100];
G g;
int main() {
	int n;
	cin >> n;

	rep(i, n) {
		int a, b;
		cin >> a >> b;
		in[i] = { {(ld)a, (ld)b},0.0 };
		g.push_back(in[i].fs);
	}
	g = andrewScan(g);
	ld t = 0.0;

	int gn = g.size();
	rep(i, gn) {
		P a = -g[i] + g[(i + gn - 1) % gn];
		P b = -g[i] + g[(i + 1) % gn];
		P d = b/a;
		d = { d.real(), -abs(d.imag()) };
		ld c = arg(d) + M_PI;
		// if (abs(d.real() + 1) < 1e-7 && abs(d.imag() < 1e-7)) c = 0.0;

		// cout << g[i] << " " << a << " " << b << " " << arg(d) << endl;
		// cout << g[i] << " " << d << " " << arg(d) <<" "<< c << endl;

		t += c;
		rep(j, n) {
			if (abs(g[i] - in[j].fs) < 0.1) {
				in[j].sc = c;
			}
		}
	}

	for (auto p : g) {
		// cout << p << endl;
	}
	rep(i, n) {
		//cout << in[i].fs << "  " ;
		//cout << in[i].sc / t << endl;
		double ret = in[i].sc / t;
		printf("%.19lf\n", ret);
	}

}



Measured memory_bytes: 256