#pragma GCC optimize("O3,unroll-loops")
#include <bits/stdc++.h>
using namespace std;

#ifdef WAIMAI
#define debug(HEHE...) cout << "[" << #HEHE << "] : ", dout(HEHE)
void dout() {cout << "\n";}
template<typename T, typename...U>
void dout(T t, U...u) {cout << t << (sizeof...(u) ? ", " : ""), dout(u...);}
#else
#define debug(...) 7122
#endif

#define ll long long
#define Waimai ios::sync_with_stdio(false), cin.tie(0)
#define FOR(x,a,b) for(int x = a, I = b; x <= I; x++)
#define pb emplace_back
#define F first
#define S second

const int SIZE = 5e5 + 5;

int n;

struct point {
    ll x = 0, y = 0;
    point() {}
    point(ll x, ll y) : x(x), y(y) {}
    point operator - (const point &o) const {
        return point(x - o.x, y - o.y);
    }
    ll operator * (const point &o) const {
        return x * o.y - y * o.x;
    }
    ll abs2() {
        return x * x + y * y;
    }
    void get() {
        cin >> x >> y;
    }
} p[SIZE];

struct Line {
    point X, Y;
    Line() {}
    Line(point X, point Y) : X(X), Y(Y) {}
};

int sign(ll x) {
    return x > 0 ? 1 : x < 0 ? -1 : 0;
}
int ori(point a, point b, point c) {
    return sign((b - a) * (c - a));
}
int cmp(point a, point b, bool same = true) {
    #define is_neg(k) (sign(k.y) < 0 || (sign(k.y) == 0 && sign(k.x) < 0))
    int A = is_neg(a), B = is_neg(b);
    if (A != B) return A < B;
    if (sign(a * b) == 0) return same ? a.abs2() < b.abs2() : -1;
    return sign(a * b) > 0;
}

pair<ll, ll> area_pair(Line a, Line b) {
    return pair<ll, ll>((a.Y - a.X) * (b.X - a.X), (a.Y - a.X) * (b.Y - a.X));
}
bool isin(Line l0, Line l1, Line l2) {
    auto [a02X, a02Y] = area_pair(l0, l2);
    auto [a12X, a12Y] = area_pair(l1, l2);
    if (a12X - a12Y < 0) a12X *= -1, a12Y *= -1;
    return (__int128) a02Y * a12X - (__int128) a02X * a12Y > 0;
}

vector<Line> halfPlaneInter(vector<Line> arr) {
    sort(arr.begin(), arr.end(), [&](Line a, Line b) ->int {
        if (cmp(a.Y - a.X, b.Y - b.X, 0) != -1) return cmp(a.Y - a.X, b.Y - b.X, 0);
        return ori(a.X, a.Y, b.Y) < 0;
    });
    deque<Line> dq(1, arr[0]);
    auto pop_back = [&](int t, Line p) {
        while (dq.size() >= t && !isin(p, dq[dq.size() - 2], dq.back())) dq.pop_back();
    };
    auto pop_front = [&](int t, Line p) {
        while (dq.size() >= t && !isin(p, dq[0], dq[1])) dq.pop_front();
    };
    for (auto p : arr) {
        if (cmp(dq.back().Y - dq.back().X, p.Y - p.X, 0) != -1) {
            pop_back(2, p);
            pop_front(2, p);
            dq.pb(p);
        }
    }
    pop_back(3, dq[0]), pop_front(3, dq.back());
    return vector<Line>(dq.begin(), dq.end());
}

pair<double, double> ints(point p1, point p2, point p3, point p4) {
    double a123 = (p2 - p1) * (p3 - p1);
    double a124 = (p2 - p1) * (p4 - p1);
    double x = (p4.x * a123 - p3.x * a124) / (a123 - a124);
    double y = (p4.y * a123 - p3.y * a124) / (a123 - a124);
    return {x, y};
}

void solve() {
    cin >> n;
    FOR (i, 1, n) p[i].get();
    reverse(p + 1, p + n + 1);
    vector<Line> v;
    FOR (i, 1, n - 1) v.pb(Line(p[i], p[i + 1]));
    v.pb(Line(p[n], p[1]));
    v = halfPlaneInter(v);
    if (v.size() <= 2) {
        cout << "0.00\n";
        return;
    }
    vector<pair<double, double>> ans;
    FOR (i, 0, v.size() - 2) ans.pb(ints(v[i].X, v[i].Y, v[i + 1].X, v[i + 1].Y));
    ans.pb(ints(v.back().X, v.back().Y, v[0].X, v[0].Y));
    double area = 0;
    ans.pb(ans[0]);
    FOR (i, 0, ans.size() - 2) {
        auto [x, y] = ans[i];
        auto [nx, ny] = ans[i + 1];
        area += x * ny - y * nx;
    }
    cout << fixed << setprecision(12) << abs(area / 2) << '\n';
}

int main() {
    Waimai;
    solve();
}