#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

using Real = long double; // modify these if needed
constexpr Real eps = 1e-9;

template <typename T>
int sign(T x) {
    return (x > 0) - (x < 0);
}
int sign(Real x) {
    return (x > eps) - (x < -eps);
}
template <typename T>
int cmp(T a, T b) {
    return sign(a - b);
}

template <typename T>
struct P {
    T x = 0, y = 0;
    P(T x = 0, T y = 0) : x(x), y(y) {}
    friend istream& operator>>(istream &is, P &p) { return is >> p.x >> p.y; }
    friend ostream& operator<<(ostream &os, P p) { return os << p.x << ' ' << p.y; }
    friend bool operator==(P a, P b) { return cmp(a.x, b.x) == 0 && cmp(a.y, b.y) == 0; }
    friend bool operator!=(P a, P b) { return !(a == b); }
    P operator-() { return P(-x, -y); }
    P& operator+=(P a) {
        x += a.x, y += a.y;
        return *this;
    }
    P& operator-=(P a) {
        x -= a.x, y -= a.y;
        return *this;
    }
    P& operator*=(T d) {
        x *= d, y *= d;
        return *this;
    }
    P& operator/=(T d) {
        x /= d, y /= d;
        return *this;
    }
    friend P operator+(P a, P b) { return P(a) += b; }
    friend P operator-(P a, P b) { return P(a) -= b; }
    friend P operator*(P a, T d) { return P(a) *= d; }
    friend P operator/(P a, T d) { return P(a) /= d; }
    friend bool operator<(P a, P b) {
        int sx = cmp(a.x, b.x);
        return sx != 0 ? sx == -1 : cmp(a.y, b.y) == -1;
    }
};

template <typename T>
struct L {
    array<P<T>, 2> l;
    L(P<T> a = {}, P<T> b = {}) : l{a, b} {}
};

template <typename T>
T dot(P<T> a, P<T> b) { return a.x * b.x + a.y * b.y; }

template <typename T>
T square(P<T> a) { return dot(a, a); }

template <typename T>
T dist2(P<T> a, P<T> b) { return square(a - b); }

template <typename T>
Real length(P<T> a) { return sqrtl(square(a)); }

template <typename T>
Real dist(P<T> a, P<T> b) { return length(a - b); }

template <typename T>
T cross(P<T> a, P<T> b) { return a.x * b.y - a.y * b.x; }

template <typename T>
T cross(P<T> p, P<T> a, P<T> b) { return cross(a - p, b - p); }

template <typename T>
P<Real> normal(P<T> a) {
    Real len = length(a);
    return P<Real>(a.x / len, a.y / len);
}

template <typename T>
bool up(P<T> a) { return sign(a.y) > 0 || sign(a.y) == 0 && sign(a.x) > 0; }

// 3 colinear? please remember to remove (0, 0)
template <typename T>
bool polar(P<T> a, P<T> b) {
    bool ua = up(a), ub = up(b);
    return ua != ub ? ua : sign(cross(a, b)) == 1;
}

template <typename T>
bool parallel(P<T> a, P<T> b) {
    return sign(cross(a, b)) == 0;
}

template <typename T>
bool sameDirection(P<T> a, P<T> b) {
    return sign(cross(a, b)) == 0 && sign(dot(a, b)) == 1;
}

// 1 if on a->b's left
template <typename T>
int side(P<T> p, P<T> a, P<T> b) { return sign(cross(p, a, b)); }

template <typename T>
int side(P<T> p, L<T> l) { return side(p, l.l[0], l.l[1]); }

template <typename T>
P<T> rotate90(P<T> p) {
    return {-p.y, p.x};
}

P<Real> rotate(P<Real> p, Real ang) {
    return {p.x * cos(ang) - p.y * sin(ang), p.x * sin(ang) + p.y * cos(ang)};
}

template <typename T>
Real angle(P<T> p) {
    return atan2(p.y, p.x);
}

template <typename T>
P<T> direction(L<T> l) {
    return l.l[1] - l.l[0];
}

template <typename T>
bool parallel(L<T> l1, L<T> l2) {
    return sameDirection(direction(l1), direction(l2));
}

template <typename T>
bool sameDirection(L<T> l1, L<T> l2) {
    return sameDirection(direction(l1), direction(l2));
}

P<Real> projection(P<Real> p, L<Real> l) {
    auto d = direction(l);
    return l.l[0] + d * (dot(p - l.l[0], d) / square(d));
}

P<Real> reflection(P<Real> p, L<Real> l) {
    return projection(p, l) * 2 - p;
}

Real pointToLineDist(P<Real> p, L<Real> l) {
    if (l.l[0] == l.l[1]) { return dist(p, l.l[0]); }
    return abs(cross(l.l[0] - l.l[1], l.l[0] - p)) / length(direction(l));
}

// better use integers if you don't need exact coordinate
// l <= r is not explicitly required

template <typename T>
P<T> lineIntersection(L<T> l1, L<T> l2) {
    return l1.l[0] - direction(l1) * (Real(cross(direction(l2), l1.l[0] - l2.l[0])) / cross(direction(l2), direction(l1)));
}

template <typename T>
bool between(T m, T l, T r) {
    return cmp(l, m) == 0 || cmp(m, r) == 0 || l < m != r < m;
}

template <typename T>
bool pointOnSeg(P<T> p, L<T> l) {
    return side(p, l) == 0 && between(p.x, l.l[0].x, l.l[1].x) && between(p.y, l.l[0].y, l.l[1].y);
}

template <typename T>
bool pointStrictlyOnSeg(P<T> p, L<T> l) {
    return side(p, l) == 0 && sign(dot(p - l.l[0], direction(l))) * sign(dot(p - l.l[1], direction(l))) < 0;
}

template <typename T>
bool overlap(T l1, T r1, T l2, T r2) {
    if (l1 > r1) { swap(l1, r1); }
    if (l2 > r2) { swap(l2, r2); }
    return cmp(r1, l2) != -1 && cmp(r2, l1) != -1;
}

template <typename T>
bool segIntersect(L<T> l1, L<T> l2) {
    auto [p1, p2] = l1;
    auto [q1, q2] = l2;
    return overlap(p1.x, p2.x, q1.x, q2.x) && overlap(p1.y, p2.y, q1.y, q2.y) &&
            side(p1, l2) * side(p2, l2) <= 0 &&
            side(q1, l1) * side(q2, l1) <= 0;
}

// parallel intersecting is false
template <typename T>
bool segStrictlyIntersect(L<T> l1, L<T> l2) {
    auto [p1, p2] = l1;
    auto [q1, q2] = l2;
    return side(p1, l2) * side(p2, l2) < 0 &&
           side(q1, l1) * side(q2, l1) < 0;
}

// parallel or intersect at source doesn't count
template <typename T>
bool rayIntersect(L<T> l1, L<T> l2) {
    int x = sign(cross(l1.l[1] - l1.l[0], l2.l[1] - l2.l[0]));
    return x == 0 ? false : side(l1.l[0], l2) == x && side(l2.l[0], l1) == -x;
}

template <typename T>
Real pointToSegDist(P<T> p, L<T> l) {
    auto d = direction(l);
    if (sign(dot(p - l.l[0], d)) >= 0 && sign(dot(p - l.l[1], d)) <= 0) {
        return pointToLineDist(p, l);
    } else {
        return min(dist(p, l.l[0]), dist(p, l.l[1]));
    }
}

template <typename T>
Real segDist(L<T> l1, L<T> l2) {
    if (segIntersect(l1, l2)) { return 0; }
	return min({pointToSegDist(l1.l[0], l2), pointToSegDist(l1.l[1], l2),
            pointToSegDist(l2.l[0], l1), pointToSegDist(l2.l[1], l1)});
}

// 2 times area
template <typename T>
T area(vector<P<T>> a) {
    T res = 0;
    int n = a.size();
    for (int i = 0; i < n; i++) {
        res += cross(a[i], a[(i + 1) % n]);
    }
    return res;
}

template <typename T>
bool pointInPoly(P<T> p, vector<P<T>> a) {
    int n = a.size(), res = 0;
    for (int i = 0; i < n; i++) {
        P<T> u = a[i], v = a[(i + 1) % n];
        if (pointOnSeg(p, {u, v})) { return 1; }
        if (cmp(u.y, v.y) <= 0) { swap(u, v); }
        if (cmp(p.y, u.y) > 0 || cmp(p.y, v.y) <= 0) { continue; }
        res ^= cross(p, u, v) > 0;
    }
    return res;
}

using Point = P<i64>;
using Line = L<i64>;

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    auto solve = [&]() {
        int n;
        cin >> n;

        vector<Point> p(n);
        for (int i = 0; i < n; i++) {
            cin >> p[i];
        }

        if (area(p) < 0) {
            reverse(p.begin(), p.end());
        }

        constexpr Real pi = numbers::pi;

        auto get = [&](int i) {
            Real x = angle(p[(i + n - 1) % n] - p[i]);
            Real y = angle(p[(i + 1) % n] - p[i]);
            if (x < y) {
                x += 2 * pi;
            }
            return x - y;
        };

        Real ans = 0;

        for (int i = 0; i < n; i++) {
            Real a = get(i), b = get((i + 1) % n);
            if (a + b < pi) {
                ans += (pi - a - b) / pi;
            }
        }

        cout << fixed << setprecision(12) << ans << '\n';
    };
    
    solve();
    
    return 0;
}