#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define double long double

const double EPS = 1e-9;
const double PI = 3.14159265358979323846;

bool doubleEqual(double a, double b) {
    return fabs(a - b) < EPS;
}

bool doubleLessOrEqual(double a, double b) {
    return doubleEqual(a, b) || a < b;
}

bool doubleLess(double a, double b) {
    return !doubleEqual(a, b) && a < b;
}

bool doubleGreaterOrEqual(double a, double b) {
    return a > b || doubleEqual(a, b);
}

bool doubleGreater(double a, double b) {
    return a > b && !doubleEqual(a, b);
}

double mySqrt(double a) {
    if (a < 0) {
        return 0;
    }
    return sqrt(a);
}

double sqr(double a) {
    return a * a;
}

struct Point {
    double x, y;
    int ind;
    Point(): x(0), y(0) {}

    Point(double x, double y): x(x), y(y) {}

    Point operator-(const Point &p) const {
        return {x - p.x, y - p.y};
    }

    Point operator+(const Point &p) const {
        return {x + p.x, y + p.y};
    }

    Point &operator+=(const Point &p) {
        x += p.x, y += p.y;
        return *this;
    }

    double operator%(const Point &p) const {
        return x * p.x + y * p.y;
    }

    double operator*(const Point &p) const {
        return x * p.y - p.x * y;
    }

    Point operator/(double k) const {
        return {x / k, y / k};
    }

    Point &operator/=(double k) {
        x /= k;
        y /= k;
        return *this;
    }

    Point operator*(double k) const {
        return {x * k, y * k};
    }

    Point &operator*=(double k) {
        x *= k, y *= k;
        return *this;
    }

    bool operator<(const Point &p) const {
        return x < p.x || (x == p.x && y < p.y);
    }

    double length() const {
        return mySqrt(*this % *this);
    }

    double distTo(const Point &p) const {
        return (*this - p).length();
    }

    double distTo(const Point &A, const Point &B) const {
        double d = A.distTo(B);
        double s = (*this - A) * (*this - B);
        return fabs(s) / d;
    }

    Point normalize(double k = 1.0) const {
        double len = length();
        return *this * (k / len);
    }

    Point getH(const Point &A, const Point &B) const {
        Point C = *this;
        Point v = B - A;
        Point u = C - A;
        double k = v % u / v.length();
        v = v.normalize(k);
        Point H = A + v;
        return H;
    }

    Point rotate() const {
        return {-y, x};
    }

    Point rotate(double alpha) const {
        Point v = *this;
        Point w;
        w.x = v.x * cos(alpha) - v.y * sin(alpha);
        w.y = v.x * sin(alpha) + v.y * cos(alpha);
        return w;
    }

    bool isOnLine(const Point &A, const Point &B) const {
        return doubleEqual((*this - A) * (*this - B), 0.0);
    }

    bool isInSegment(const Point &A, const Point &B) const {
        return isOnLine(A, B) && doubleLessOrEqual((A - *this) % (B - *this), 0);
    }

    bool isInSegmentStrictly(const Point &A, const Point &B) const {
        return isOnLine(A, B) && doubleLess((A - *this) % (B - *this), 0);
    }

    double getAngle() {
        return atan2(y, x);
    }

    double getAngle(const Point &p) const {
        return atan2(p * *this, p % *this);
    }
};

int getTangent(const Point & A, const Point & O, double r, Point & M, Point & N) {
    Point v = O - A;
    double d = v.length();
    double alpha = asin(r / d);
    double L = mySqrt(sqr(d) - sqr(r));
    v = v.normalize(L);
    M = A + v.rotate(alpha);
    N = A + v.rotate(-alpha);
    if (doubleEqual(r, d)) return 1;
    return 2;
}


istream &operator>>(istream &in, Point &A) {
    in >> A.x >> A.y;
    return in;
}

ostream &operator<<(ostream &in, Point &A) {
    in << A.x << A.y;
    return in;
}

Point O;

bool cmp(const Point &A, const Point &B) {
    return (A - O) * (B - O) < 0 || ((A - O) * (B - O) == 0 && (A - O).length() < (B - O).length());
}

vector<Point> convexHull(vector<Point> &a) {
    vector<Point> convex;
    convex.push_back(O);
    for (int i = 1; i < a.size(); ++i) {
        while (convex.size() > 1 && (convex.back() - convex[convex.size() - 2]) * (a[i] - convex.back()) >= 0) {
            convex.pop_back();
        }
        convex.push_back(a[i]);
    }
    return convex;
}

int main() {
#ifdef MY
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<Point> pts(n);
    int cnt = 0;
    for (auto &p: pts) {
        cin >> p;
        p.ind = cnt++;
    }
    sort(pts.begin(), pts.end());
    O = pts[0];
    sort(pts.begin() + 1, pts.end(), cmp);
    auto data = convexHull(pts);
    vector<double> ans(n, 0.0);
    for (int i = 0; i < data.size(); ++i) {
        int next = (i + 1) % data.size();
        int prev = (i - 1 + data.size()) % data.size();
        Point A = data[prev], B = data[i], C = data[next];
        Point v = B - A;
        v = v.rotate();
        Point u = (C - B).rotate();
        ans[data[i].ind] = fabs(atan2(u * v, u % v) / 2 / PI);
    }
    cout << fixed << setprecision(20);
    for (auto x: ans) {
        cout << x << "\n";
    }
}

Measured memory_bytes: 256