#include <iostream>
#include <cstdio>
#include <string>
#include <string.h>
#include <queue>
#include <math.h>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <bitset>
#include <list>
#include <ctype.h>
#include <cassert>
#include <stack>
#include <fstream>
#include <unordered_map>
#include <unordered_set>
#include <ctime>
#include <functional>
#include <ctime>
#include <limits>
#include <tuple>
#include <complex>
#include <numeric>
#include <future>

using namespace std;

#define snd second
#define fst first
#define mp make_pair
#define ll long long
#define ull unsigned long long
#define ld long double
#define pb push_back
#define left _left
#define right _right

const ld pi = acos(-1.0);

template<typename T>
T abs(T x) {
    return x > 0 ? x : -x;
}

template<typename T>
T sqr(T x) {
    return x * x;
}

template<typename T>
bool chmin(T &x, T y) {
    if (x > y) {
        x = y;
        return true;
    }
    return false;
}

template<typename T>
bool chmax(T &x, T y) {
    if (x < y) {
        x = y;
        return true;
    }
    return false;
}

template<typename U, typename V>
ostream &operator<<(ostream &s, const pair<U, V> &x) {
    s << "(" << x.fst << ", " << x.snd << ")";
    return s;
}

template<typename U>
ostream &operator<<(ostream &s, const vector<U> &x) {
    s << "[";
    bool was = false;
    for (auto it : x) {
        if (was) {
            s << ", ";
        }
        was = true;
        s << it;
    }
    s << "]";
    return s;
}

template<typename U>
ostream &operator<<(ostream &s, const set<U> &x) {
    s << "{";
    bool was = false;
    for (auto it : x) {
        if (was) {
            s << ", ";
        }
        was = true;
        s << it;
    }
    s << "}";
    return s;
}

template<int sz>
ostream operator<<(ostream &s, const bitset<sz> &x) {
    for (int i = 0; i < sz; i++) {
        s << x[i];
    }
    return s;
}


//--------------------------------------------------------------------------

string s;

const int maxn = 305;

int dp[maxn][maxn][maxn];

int f(int l, int r, int k) {
    if (l > r) {
        return 0;
    }
    if (dp[l][r][k] != -1) {
        return dp[l][r][k];
    }

    int& res = dp[l][r][k];
    res = 0;

    if (l == r) {
        return res = 1;
    } else if (s[l] == s[r]) {
        chmax(res, 2 + f(l + 1, r - 1, k));
    } else if (k) {
        chmax(res, 2 + f(l + 1, r - 1, k - 1));
    }
    chmax(res, f(l + 1, r, k));
    chmax(res, f(l, r - 1, k));
    return res;
}

int main() {

    srand(time(NULL));

#ifdef LOCAL
    //gen();
    freopen("a.in", "r", stdin);
    //freopen("a.in", "w", stdout);
#else
    //freopen("brackets.in", "r", stdin);
    //freopen("brackets.out", "w", stdout);
#endif


//    cin >> s;
//    for (int i = 0; i < maxn; i++) {
//        for (int j = 0; j < maxn; j++) {
//            for (int h = 0; h < maxn; h++) {
//                dp[i][j][h] = -1;
//            }
//        }
//    }
//    int k;
//    cin >> k;
//    cout << f(0, s.size() - 1, k) << endl;

    int n;
    cin >> n;
    vector<pair<ll, ll>> a(n);

    for (int i = 0; i < n; i++) {
        cin >> a[i].fst >> a[i].snd;
    }

    vector<ld> ans(n);
    const int iter = 2e6;
    for (int i = 0; i < iter; i++) {
        ld ang = 2 * pi / iter * i;
        ld x = cos(ang) * 1e30;
        ld y = sin(ang) * 1e30;
        pair<ld, int> bst(1e300, 0);
        for (int j = 0; j < n; j++) {
            ld d = -2 * x * a[j].fst - 2 * y * a[j].snd + sqr(a[j].fst) + sqr(a[j].snd);
            chmin(bst, mp(d, j));
        }
        ans[bst.snd] += 1;
    }
    cout.precision(10);
    for (auto& x : ans) {
        x /= iter;
        cout << fixed << x << endl;
    }


    return 0;
}

Measured memory_bytes: 384