#include <bits/stdc++.h>


#define DMAX 
#define NMAX 
#define MMAX 

#define EPS 1e-9
const double PI = acos(-1);

using namespace std;


void debug_out() { cerr << endl; }
template<class T> ostream& prnt(ostream& out, T v) { out << v.size() << '\n'; for(auto e : v) out << e << ' '; return out;}
template<class T> ostream& operator<<(ostream& out, vector <T> v) { return prnt(out, v); }
template<class T> ostream& operator<<(ostream& out, set <T> v) { return prnt(out, v); }
template<class T1, class T2> ostream& operator<<(ostream& out, map <T1, T2> v) { return prnt(out, v); }
template<class T1, class T2> ostream& operator<<(ostream& out, pair<T1, T2> p) { return out << '(' << p.st << ' ' << p.nd << ')'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << H; debug_out(T...);}

#define dbg(...) cerr << #__VA_ARGS__ << " ->", debug_out(__VA_ARGS__)
#define dbg_v(x, n) do{cerr<<#x"[]: ";for(int _=0;_<n;++_)cerr<<x[_]<<" ";cerr<<'\n';}while(0)
#define dbg_ok cerr<<"OK!\n"


int n, k;
string s;



struct point{
	double x, y;
	int i;	
	point() {	}
	point(const point &a) {x = a.x, y = a.y; i = a.i;}
	point(double _x, double _y) { x = _x; y = _y; }

	point operator-(point &a) {return point(x - a.x, y - a.y);}
	point operator+(point &a) {return point(x + a.x, y + a.y);}
	point operator*(double val) {return point(x * val, y * val);}
	point operator/(double val) {return point(x / val, y / val);}

  bool operator<(const point &a) const { if(fabs(x - a.x) < EPS) {if(fabs(y - a.y) < EPS) return false; return y < a.y;} return x < a.x; }
  bool operator==(const point &a) const { if(fabs(x - a.x) < EPS) if(fabs(y - a.y) < EPS) return true; return false; }

  point rot() {return point(-y, x);}
  double norm() {return x*x + y*y; }
  double len() {return sqrt(norm()); }

	void rot(long double alfa) {
		long double cx = x;
		x = x * cos(alfa) - y * sin(alfa);
		y = y * cos(alfa) + cx * sin(alfa);
	}
};

ostream& operator<<(ostream& out, point p) { return out << p.x << ' ' << p.y; }

struct line
{
	double m, n;

	line(point A, point B) {
		m = (A.y - B.y) / (A.x - B.x) ;
		n = A.y - m * A.x;
	}

	line(point A, double _m) {
		// linia de panta _m care trece prin punctul A
		m = _m;
		n = A.y - m * A.x; 
	}

	line(double _m, double _n) {
		m = _m;
		n = _n;
	}

	point intersect(line l) {
		// returneaza punctul in care se intersecteaza linia this cu linia l
		point O;
		//if(m == l.m)
		// return 
		O.x = (l.n - n) / (m - l.m);
		O.y = m * O.x + n;
		return O;
	}

};


long double dist(point a, point b)
{
	long double X = a.x - b.x;
	long double Y = a.y - b.y;
	return sqrt(X * X + Y * Y);
}

struct circle {
	point o;
	double r;

	circle() {}
	circle(point a, point b, point c) {
		point mab = (a + b) / 2.;
		point mbc = (c + b) / 2.;
		line ab(a, b), bc(b, c);
		line ab1(mab, -1.0/ab.m);
		line bc1(mbc, -1.0/bc.m);
		o = ab1.intersect(bc1);
		r = dist(o, a);
	} 

};

struct seg {
	point a, b;

	seg(point _a, point _b) { a = _a, b = _b; };
};


istream& operator>>(istream& in, point &p) { return in >> p.x >> p.y; }

istream& operator>>(istream& in, circle &c) { return in >> c.o >> c.r; }

istream& operator>>(istream& in, seg &s) { return in >> s.a >> s.b; }

long double area(point a, point b, point c) {
	return a.x * b.y + b.x * c.y + c.x * a.y - a.y * b.x - b.y * c.x - c.y * a.x;
}

bool isObtouseAngle(point A, point B, point C) {
	//check if A angle is obtuse
	double a = dist(B, C);
	double b = dist(A, C);
	double c = dist(B, A);
	a *= a;
	b *= b;
	c *= c;
	if(b + c < a)
		return true;
	return false;
}

double dist(point p, seg s) {
	if(isObtouseAngle(s.a, s.b, p) || dist(s.a, s.b) <= EPS || isObtouseAngle(s.b, s.a, p))
		return min(dist(p, s.a), dist(p, s.b));
	return fabs(area(p, s.a, s.b)) / dist(s.a, s.b);
}


bool checkInt(seg a, seg b)
{
	if(area(a.a, a.b, b.a) * area(a.a, a.b, b.b) >= EPS)
		return false;
	if(area(b.a, b.b, a.a) * area(b.a, b.b, a.b) >= EPS)
		return false;
	return true;
}

point cmp_point;
bool cmp(point a, point b) {
	if(area(cmp_point, a, b) == 0)
		return a.x < b.x;
	return area(cmp_point, a, b) > 0;
}

vector <point> hull(vector <point> &pts) {

	int ind = 0;
	for(int i = 1; i < pts.size(); i++) 
		if(pts[i] < pts[ind]) 
			ind = i;

	swap(pts[pts.size() - 1], pts[ind]);
	cmp_point = pts.back();
	// dbg(cmp_point);
	pts.pop_back();
	// dbg(pts);

	sort(pts.begin(), pts.end(), cmp);
	// dbg(pts);

	vector <point> hull;
	hull.push_back(cmp_point);
	for(int i = 0; i < pts.size(); i++) {
		 while (hull.size() > 2 && area(hull[hull.size()-2],hull[hull.size() - 1],pts[i]) < 0) {
	      hull.pop_back();
	    }
	    assert(pts[i].i <= 100);
	    hull.push_back(pts[i]);
	}
	return hull;
}


double pr[112];

int main()
{
	ios_base::sync_with_stdio(false);
	cout << fixed << setprecision(9);
	cin >> n;
	point pp;
	vector <point> p;
	for(int i = 1; i <= n; i++) {
		cin >> pp;
		pp.i = i;
		p.push_back(pp);
	}

	auto h = hull(p);
	dbg(h);
	for(int i = 0; i < h.size(); i++) {
		// dbg(i);

		int j = (i + 1) % h.size();
		int k = (j + 1) % h.size();
		double A = dist(h[i], h[j]);
		double B = dist(h[j], h[k]);
		double C = dist(h[i], h[k]);

		double alfa = fabs(area(h[i], h[j], h[k])) / (A * B);
		// dbg(alfa);	
		alfa = asin(alfa);
		// if(alfa == 0) continue;

		// dbg(area(h[i], h[j], h[k]));
		// dbg(dist(h[i], h[j]));
		// dbg(dist(h[j], h[k]));
		// dbg(j + 1);
		// dbg(alfa / PI * 180.);
		if(C * C <= A * A + B * B)
			alfa = PI - alfa;
		// if(alfa == 0) continue;

		dbg(alfa / PI * 180.);
		// dbg(j);
		// dbg(h[j].i);
		pr[h[j].i] = alfa / (2 * PI);
		dbg_ok;
	}
	cout << fixed << setprecision(10);
	for(int i = 1; i <= n; i++)
		cout << pr[i] << '\n';
}

Measured memory_bytes: 256