#define _USE_MATH_DEFINES

#include <iostream>
#include <iomanip>
#include <random>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <numeric>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <sstream>
#include <bitset>
#include <cassert>
#include <fstream>

#define len(X) ((int)(X).size())

#ifdef __LOCAL
	#define DBG(X) cout << #X << "=" << (X) << endl;
#else
	#define DBG(X)
	#define endl '\n'
#endif
 
using namespace std;

using ll = long long int;
using ull = unsigned long long int;
using ld  = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;

const int INT_INF = (int)(2e9);
const ll  LL_INF  = (ll)(2e18);

const ll mod = 1e9 + 7;
const int NIL = -1;
static mt19937 _g(time(nullptr));

inline ll randint(ll a, ll b) { ll w = (_g() << 31LL) ^ _g(); return a + w % (b - a + 1); }
inline void fast_io() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); };
template<typename T> inline T sign(T x) { return T(x > 0) - T(x < 0); }
template<typename T, typename S> inline ostream& operator<<(ostream& os, const pair<T, S> p) { cout << "[" << p.first << ";" << p.second << "]"; return os; }
template<typename T> inline ostream& operator<<(ostream& os, const vector<T>& v) { for(auto el: v) cout << el << " "; return os; }

struct Vector
{
	ld x, y;
	int id;

	Vector(): x(0), y(0), id(NIL)
	{
	}

	Vector(ld _x, ld _y): x(_x), y(_y), id(NIL)
	{
	}

	Vector(ld _x, ld _y, int _id): x(_x), y(_y), id(_id)
	{
	}

	Vector operator+(const Vector& other) const
	{
		return Vector(x + other.x, y + other.y);
	}

	Vector operator-(const Vector& other) const
	{
		return Vector(x - other.x, y - other.y);
	}

	bool operator<(const Vector& other) const
	{
		return tie(x, y) < tie(other.x, other.y);
	}

	ld operator%(const Vector& other) const
	{
		return x * other.x + y * other.y;
	}

	ld sqlen() const
	{
		return (*this) % (*this);
	}

	ld length() const
	{
		return sqrt(sqlen());
	}

	ld operator^(const Vector& other) const
	{
		return x * other.y - y * other.x;
	}

	Vector rotate90() const
	{
		return Vector(-y, x);
	}

	Vector operator*(ld lambda) const
	{
		return Vector(x * lambda, y * lambda);
	}
};

ostream& operator<<(ostream& os, const Vector& vec)
{
	os << "{" << vec.x << " ; " << vec.y << "}";

	return os;
}

const ld eps = 1e-6;
const int MAX_N = 107;

Vector pts[MAX_N], convex_hull[MAX_N];
int n, sz = 0;

bool convex_hull_comp(const Vector& lhs, const Vector& rhs)
{
	ld value = (lhs - pts[0]) ^ (rhs - pts[0]);

	if(abs(value) > eps)
		return value > 0;

	return lhs.sqlen() < rhs.sqlen();
}

ld answ[MAX_N];

Vector midper(const Vector& A, const Vector& B)
{
	return (B - A).rotate90();
}

void solve()
{
	cin >> n;

	for(int i = 0; i < n; ++i)
	{
		cin >> pts[i].x >> pts[i].y;
		pts[i].id = i;

		answ[i] = 0.;
	}

	int pos = min_element(pts, pts + n) - pts;
	swap(pts[0], pts[pos]);

	sort(pts + 1, pts + n, convex_hull_comp);

	int i = 0;

	while(i < n)
	{
		while(sz >= 2)
		{
			Vector A = convex_hull[sz - 2];
			Vector B = convex_hull[sz - 1];

			ld value = (B - A) ^ (pts[i] - B);

			if(value < -eps)
				--sz;
			else
				break;
		}

		convex_hull[sz++] = pts[i++];
	}

	DBG(sz);

	for(int i = 0; i < sz; ++i)
		DBG(convex_hull[i]);

	for(int i = 0; i < sz; ++i)
	{
		int nxt = (i + 1 >= sz ? i + 1 - sz : i + 1);
		int prv = (i - 1 < 0 ? i - 1 + sz : i - 1);

		Vector left = midper(convex_hull[prv], convex_hull[i]);
		Vector right = midper(convex_hull[i], convex_hull[nxt]);

		ld p = atan2(left ^ right, left % right);

		if(p < 0.)
			p += 2 * M_PI;

		answ[convex_hull[i].id] = p / (2 * M_PI);
	}

	for(int i = 0; i < n; ++i)
		cout << fixed << setprecision(12) << answ[i] << " ";

	cout << endl;
}

int main()
{
	fast_io();
	solve();

	return 0;
}


Measured memory_bytes: 256