#include <cassert>
#include <cmath>
#include <iostream>
#include <tuple>
#include <vector>

template<typename T> struct Point {
    T x, y;
    explicit Point(T x = 0, T y = 0) : x(x), y(y) {}
    [[nodiscard]] auto len2() const {
        return x * x + y * y;
    }
    [[nodiscard]] auto len() const {
        return std::sqrt(len2());
    }
};
template<typename T> using Vector = Point<T>;
template<typename T> using Line = std::pair<Point<T>, Point<T>>;

template<typename T, typename U> auto operator+(const Point<T> &a, const Point<U> &b) {
    return Point(a.x + b.x, a.y + b.y);
}
template<typename T, typename U> auto operator-(const Point<T> &a, const Point<U> &b) {
    return Point(a.x - b.x, a.y - b.y);
}
template<typename T, typename U> auto operator*(const Point<T> &a, const U &k) {
    return Point(a.x * k, a.y * k);
}
template<typename T, typename U> auto operator*(const U &k, const Point<T> &a) {
    return Point(a.x * k, a.y * k);
}
template<typename T, typename U> auto operator/(const Point<T> &a, const U &k) {
    return Point(a.x / k, a.y / k);
}
template<typename T, typename U> auto det(const Point<T> &a, const Point<U> &b) {
    return a.x * b.y - a.y * b.x;
}
template<typename T, typename U> auto dot(const Point<T> &a, const Point<U> &b) {
    return a.x * b.x + a.y * b.y;
}
template<typename T>
auto point_line_distance(const Point<T> &p, const Point<T> &a, const Point<T> &b) {
    return std::fabs(det(a - p, b - p) / (a - b).len());
}
template<typename T>
int line_line_intersection(
    const Point<T> &a, const Point<T> &b, const Point<T> &c, const Point<T> &d, Point<double> &O
) {
    if (det(b - a, d - c) == 0) {
        if (det(b - a, c - a) == 0) {
            return -1;
        }
        return 0;
    }
    auto s1 = det(d - a, c - a);
    auto s2 = det(c - b, d - b);
    O = a + 1.0 * s1 / (s1 + s2) * (b - a);
    return 1;
}
const int M = 1e5 + 10;

Point<long long> P[M], Q[4 * M];
std::pair<long long, long long> a[4 * M];
bool mark[4 * M];
int p[4 * M];
int n;

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        long long x, y;
        scanf("%lld %lld", &x, &y);
        P[i] = Point(2 * x, 2 * y);
    }
    for (int i = 0; i < n; ++i) {
        Q[2 * i] = P[i];
        Q[2 * i + 1] = (P[i] + P[(i + 1) % n]) / 2;
    }
    for (int i = 0; i < 2 * n; ++i) {
        Q[i + 2 * n] = Q[i];
    }
    for (int i = 0; i < 4 * n; ++i) {
        Point A = Q[(i - 1 + 4 * n) % (4 * n)];
        Point B = Q[(i + 1) % (4 * n)];
        a[i] = i & 1 ? std::make_pair((A - B).len2(), 0LL)
                     : std::make_pair(dot(Q[i] - A, Q[i] - B), det(Q[i] - A, Q[i] - B));
    }
    // for (int i = 0; i < 2 * n; ++i) {
    //     printf("%lld\n", a[i]);
    // }
    std::vector<Line<long long>> axis;
    for (int i = 0, l = 0, r = -1; i < 4 * n; ++i) {
        int k = r < i ? 0 : std::min(p[l + r - i], r - i);
        while (0 <= i - k - 1 && i + k + 1 < 4 * n && a[i - k - 1] == a[i + k + 1]) {
            ++k;
        }
        p[i] = k;
        if (r < i + k) {
            l = i - k;
            r = i + k;
        }
        // printf("%d %d\n", i, p[i]);
        if (p[i] >= n) {
            if (!mark[i] && !mark[i - n]) {
                mark[i] = true;
                mark[i + n] = true;
                axis.emplace_back(Q[i], Q[i + n]);
            }
        }
    }
    if (axis.empty()) {
        puts("0");
    } else if (axis.size() == 1) {
        double ans = 0;
        for (int i = 0; i < n; ++i) {
            auto v = P[i] - P[(i + 1) % n];
            auto u = axis[0].first - axis[0].second;
            auto r1 = point_line_distance(P[i], axis[0].first, axis[0].second);
            auto r2 = point_line_distance(P[(i + 1) % n], axis[0].first, axis[0].second);
            auto h = fabs(dot(v, u)) / u.len();
            // printf("%lf %lf %lf\n", r1, r2, h);
            ans += M_PI * (r1 * r1 + r2 * r2 + r1 * r2) * h / 3;
        }
        printf("%.10lf\n", ans / 16);
    } else {
        Point<double> O;
        int ret = line_line_intersection(
            axis[0].first, axis[0].second, axis[1].first, axis[1].second, O
        );
        // assert(ret == 1);
        double r = 0;
        for (int i = 0; i < n; ++i) {
            r = std::max(r, (P[i] - O).len());
        }
        printf("%.10lf\n", 4.0 / 3.0 * M_PI * r * r * r / 8);
    }
    return 0;
}