#include "bits/stdc++.h"
#define rep(i, a, n) for(auto i = a; i <= (n); i++)
#define per(i, a, n) for(auto i = n; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define FI first
#define SE second
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if(a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if(b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(pair<A, B> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<size_t N> string to_string(bitset<N> v) 
{
    string res = "";
    for(size_t i = 0; i < N; i++) res += static_cast<char>('0' + v[i]);
    return res;
}
template<class A> string to_string(A v)
{
    bool first = 1;
    string res = "{";
    for(const auto &x: v) 
    {
        if (!first) res += ", ";
        first = 0;
        res += to_string(x);
    }
    res += "}";
    return res;
}
template<class A, class B> string to_string(pair<A, B> p) { return "(" + to_string(p.FI) + ", " + to_string(p.SE) + ")"; }

void debug_out() { cerr << endl; }
template<class Head, class... Tail> void debug_out(Head H, Tail... T) 
{
    cerr << " " << to_string(H);
    debug_out(T...);
}
#ifndef ONLINE_JUDGE
    #define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
    #define debug(...) if(0) puts("No effect.")
#endif

using ll = long long;
// using LL = __int128;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using db = double;
using ldb = long double;

const int inf = 0x3f3f3f3f;

const db pi = acos(-1.0);

template<class T> struct TPoint {
    // use T = double or T = long long.   
    using P = TPoint;
    static constexpr T eps = static_cast<T>(1e-9);
    static int sgn(T x) { return (x > eps) - (x < -eps); }
    static int cmp(T x, T y) { return sgn(x - y); }
    static T sqr(T x) { return x * x; }

    T x, y;

    P operator +(P a) const { return P{x + a.x, y + a.y}; }
    P operator -(P a) const { return P{x - a.x, y - a.y}; }
    P operator *(T a) const { return P{x * a, y * a}; }
    P operator /(T a) const { return P{x / a, y / a}; }
    bool operator ==(P a) const { return cmp(x, a.x) == 0 && cmp(y, a.y) == 0; }
    bool operator <(P a) const { return cmp(x, a.x) == 0 ? cmp(y, a.y) < 0: x < a.x; }

    T len() const { return sqrt(sqr(x) + sqr(y)); } // I believe that you should not use this function when T = long long.
    T dis_to(P a) const { return (*this - a).len(); }
    T len2() const { return sqr(x) + sqr(y); }
    inline P unit() const {
        if (eps != 0) return len() <= eps ? P{} : *this / len(); // for float.
        else return * this; // for long long
    }

    T dot(P b) const { return x * b.x + y * b.y; }
    T cross(P b) const { return x * b.y - y * b.x; }
    bool is_upper() const { return y > eps || (sgn(y) == 0 && x < -eps); }
    static int cmp_polar(const P &a, const P &b) {
        if (eps != 0) return atan2(a.y, a.x) < atan2(b.y, b.x);
        if (a.is_upper() != b.is_upper()) return a.is_upper() < b.is_upper();
        return a.unit().cross(b.unit()) > eps;
        // one issue of this function is that if you use float-type and the values have large range then colinear points might be viewed as non-colinear.
    }
    P rot90() { return P{-y, x}; }

    P rotate(db theta) const {
        P a{cos(theta), sin(theta)};
        return P{x * a.x - y * a.y, x * a.y + y * a.x};
    }
    T project_len(P a, P b) const { return (*this - a).dot((b - a).unit()); } // signed.
    T dis_to_line(P a, P b) const { return (*this - a).cross((b - a).unit()); } // signed, return 0 if a == b.
    T dis_to_seg(P a, P b) const {
        if(project_len(a, b) < -eps) return (*this - a).len();
        if(project_len(b, a) < -eps) return (*this - b).len();
        return fabs(dis_to_line(a, b));
    }
    P project_to_line(P a, P b) const { return a + (b - a) * project_len(a, b); }
    bool on_seg(P a, P b) const { return dis_to_seg(a, b) <= eps; } // including vertice a and b.
    bool on_line(P a, P b) const { return sgn(dis_to_line(a, b)) == 0; }
};
using T = db;
using P = TPoint<T>;
using vp = vector<P>;

string to_string(const P& p) { return "(" + to_string(p.x) + ", " + to_string(p.y) + ")"; }

struct L
{
    P v[2];
    P& operator[](int i) const { return (P&)v[i]; }
    P dir() const { return v[1] - v[0]; }
    bool include(P p) const { return p.dis_to_line(v[0], v[1]) < -P::eps; }
    bool operator <(const L &rhs) const { return P::cmp_polar(dir(), rhs.dir()); }
    pair<int, P> intersect(const L &rhs) const
    {
        auto s0 = (v[0] - rhs[0]).cross(rhs.dir());
        auto s1 = (v[1] - rhs[0]).cross(rhs.dir());
        if(P::cmp(s0, s1) == 0) return mp(0, P{});
        return mp(1, (v[1] * s0 - v[0] * s1) / (s0 - s1));
    }
};

vp HPI(vector<L> ls)
{   // please make sure l is closed.   
    auto Samedir = [](L r, L s) { return (r < s || s < r) == 0; };
    sort(all(ls), [&](L r, L s) { return Samedir(r, s) ? s.include(r[0]) : r < s; });

    // assuming l is closed then the intersect function should be fine.
    auto check = [](L w, L r, L s) { return w.include(r.intersect(s).SE); };
    
    deque<L> q;
    rep(i, 0, sz(ls) - 1)
    {
        if(i && Samedir(ls[i], ls[i - 1])) continue;
        while(sz(q) > 1 && !check(ls[i], q.end()[-2], q.end()[-1])) q.pop_back();
        while(sz(q) > 1 && !check(ls[i], q[0], q[1])) q.pop_front();
        q.pb(ls[i]);
    }
	while (sz(q) > 2 && !check(q[0], q.end()[-2], q.end()[-1])) q.pop_back();
	while (sz(q) > 2 && !check(q.end()[-1], q[0], q[1])) q.pop_front();
    vp res;
    rep(i, 0, sz(q) - 1) res.pb(q[i].intersect(q[(i + 1) % sz(q)]).SE);
    return res;
}


int main()
{
    ios::sync_with_stdio(0); cin.tie(0);

    int n; cin >> n;
    vp a(n);
    for(auto &[x, y]: a) cin >> x >> y;
    auto check = [&](T ratio) 
    {
        auto next = [&](int i) { return i == n - 1 ? 0 : i + 1; };
        int ptr = 1;
        vector<L> ls;
        rep(i, 0, n - 1)
        {
            P &p = a[i], &q = a[next(i)];
            while((q - p).cross(a[ptr] - p) < (q - p).cross(a[next(ptr)] - p)) ptr = next(ptr);
            P A = (p - a[ptr]) * (ratio / (1 + ratio)) + a[ptr];
            P B = (q - a[ptr]) * (ratio / (1 + ratio)) + a[ptr];
            //debug(ratio,ptr,A.x,A.y,B.x,B.y);
            ls.pb(L{A, B});
        }
        auto res = HPI(ls);
        return sz(res) >= 3;
    };
    db l = 1, r = 2;
    rep(_, 1, 60)
    {
        db mid = (l+r)/2;
        if(check(mid)) r = mid;
        else l = mid;
    }
    printf("%.10f\n", l);
    return 0;
}