#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
using namespace std;
const long long mod=1000000007;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;

const long double EPS=1e-13;
const long double PI=acos(-1.0);
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
long double ABS(long double a){return max(a,-a);}

const long double INF = 1e+10;
int sig(long double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }

struct Pt {
	long double x, y;
	Pt() {}
	Pt(long double x, long double y) : x(x), y(y) {}
	Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
	Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
	Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
	Pt operator-() const { return Pt(-x, -y); }
	Pt operator*(const long double &k) const { return Pt(x * k, y * k); }
	Pt operator/(const long double &k) const { return Pt(x / k, y / k); }
	long double ABS() const { return sqrt(x * x + y * y); }
	long double abs2() const { return x * x + y * y; }
	long double arg() const { return atan2(y, x); }
	long double dot(const Pt &a) const { return x * a.x + y * a.y; }
	long double det(const Pt &a) const { return x * a.y - y * a.x; }
};
long double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }
inline bool operator<(const Pt &a,const Pt &b){
	if(sig(a.x-b.x)){
		return sig(a.x-b.x)<0;
	}
	return sig(a.y-b.y)<0;
}
int iSP(Pt a, Pt b, Pt c) {
	int s = sig((b - a).det(c - a));
	if (s) return s;
	if (sig((b - a).dot(c - a)) < 0) return -2; // c-a-b
	if (sig((a - b).dot(c - b)) < 0) return +2; // a-b-c
	return 0;
}
int iLL(Pt a, Pt b, Pt c, Pt d) {
	if (sig((b - a).det(d - c))) return 1; // intersect
	if (sig((b - a).det(c - a))) return 0; // parallel
	return -1; // correspond
}
bool iLS(Pt a, Pt b, Pt c, Pt d) {
	return (sig(tri(a, b, c)) * sig(tri(a, b, d)) <= 0);
}
bool iSS(Pt a, Pt b, Pt c, Pt d) {
	return (iSP(a, b, c) * iSP(a, b, d) <= 0 && iSP(c, d, a) * iSP(c, d, b) <= 0);
}
bool iSSstrict(Pt a, Pt b, Pt c, Pt d) {
	return (sig(tri(a, b, c)) * sig(tri(a, b, d)) < 0 && sig(tri(c, d, a)) * sig(tri(c, d, b)) < 0);
}
Pt pLL(Pt a, Pt b, Pt c, Pt d) {
	b = b - a; d = d - c; return a + b * (c - a).det(d) / b.det(d);
}
Pt hLP(Pt a,Pt b,Pt c){
	return pLL(a,b,c,c+(b-a)*Pt(0,1));
}
long double dLP(Pt a, Pt b, Pt c) {
	return ABS(tri(a, b, c)) / (b - a).ABS();
}
long double dSP(Pt a, Pt b, Pt c) {
	if (sig((b - a).dot(c - a)) <= 0) return (c - a).ABS();
	if (sig((a - b).dot(c - b)) <= 0) return (c - b).ABS();
	return ABS(tri(a, b, c)) / (b - a).ABS();
}
long double dLL(Pt a, Pt b, Pt c, Pt d) {
	return iLL(a, b, c, d) ? 0 : dLP(a, b, c);
}
long double dLS(Pt a, Pt b, Pt c, Pt d) {
	return iLS(a, b, c, d) ? 0 : min(dLP(a, b, c), dLP(a, b, d));
}
long double dSS(Pt a, Pt b, Pt c, Pt d) {
	return iSS(a, b, c, d) ? 0 : min(min(dSP(a, b, c), dSP(a, b, d)), min(dSP(c, d, a), dSP(c, d, b)));
}
int convexHull(int n, Pt p[], Pt q[]) {
	int m = 0, i, r;
	sort(p, p + n);
	for (i = 0; i < n; q[m++] = p[i++]) for (; m > 1 && sig(tri(q[m - 2], q[m - 1], p[i])) <= 0; --m);
	for (i = n - 2, r = m; i >= 0; q[m++] = p[i--]) for (; m > r && sig(tri(q[m - 2], q[m - 1], p[i])) <= 0; --m);
	return m - 1;
}
Pt p[110];
Pt r[110];
Pt q[110];

long double th[110];
int main(){
	int a;scanf("%d",&a);
	for(int i=0;i<a;i++){
		long double X,Y;scanf("%Lf%Lf",&X,&Y);
		X+=0.114514;
		Y+=0.364364;
		p[i]=Pt(X,Y);
		p[i]=p[i]*Pt(cos(0.1),sin(0.1));
		r[i]=p[i];
	}
	int sz=convexHull(a,p,q);
//	Pt g=Pt(0,0);
//	for(int i=0;i<sz;i++)g=g+q[i];
//	g=g/sz;
//	for(int i=0;i<sz;i++)q[i]=q[i]-g;
	//if(sz>2)return 1;
	q[sz]=q[0];
	q[sz+1]=q[1];
	for(int i=0;i<sz;i++){
		th[i]=((q[i+1]-q[i]).arg()-(q[i]-q[(i+sz-1)%sz]).arg());
	//	if(th[i]>PI*2-EPS)th[i]-=PI*2;
		if(th[i]<-1e-15)th[i]+=PI*2;
	//	th[i]/=2;
	}
//	for(int i=0;i<sz;i++)printf("%f %f: %f\n",q[i].x,q[i].y,th[i]);
	
	for(int i=0;i<a;i++){
		bool ok=false;
		for(int j=0;j<sz;j++){
			if((q[j]-r[i]).ABS()<0.5){
				printf("%.12Lf\n",th[j]/PI/2);
				ok=true;break;
			}
		}
		if(!ok)printf("0\n");
	}
}

Measured memory_bytes: 128