#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int MAXN = 2e3 + 5;
const ldb eps = 1e-9;
const ldb pi = acosl(-1);

mt19937 rnd((unsigned long long)new char ^time(0));
uniform_real_distribution<ldb> rndang(-pi, pi);

inline int sgn(ldb x) {
    return x < -eps ? -1 : x > eps ? 1 : 0;
}

struct Vector {
    ldb x, y;
    Vector(void) {}
    Vector(ldb _x, ldb _y): x(_x), y(_y) {}
    inline ldb len(void) const {
        return sqrtl(x * x + y * y);
    }
    inline ldb ang(void) const {
        return atan2l(y, x);
    }
};
Vector operator + (const Vector &p, const Vector &q) {
    return Vector(p.x + q.x, p.y + q.y);
}
Vector operator - (const Vector &p, const Vector &q) {
    return Vector(p.x - q.x, p.y - q.y);
}
Vector operator - (const Vector &p) {
    return Vector(-p.x, -p.y);
}
Vector operator * (const Vector &p, ldb k) {
    return Vector(p.x * k, p.y * k);
}
Vector operator / (const Vector &p, ldb k) {
    return Vector(p.x / k, p.y / k);
}
ldb cross(const Vector &p, const Vector &q) {
    return p.x * q.y - p.y * q.x;
}
ldb dot(const Vector &p, const Vector &q) {
    return p.x * q.x + p.y * q.y;
}
ldb dist(const Vector &p, const Vector &q) {
    return (p - q).len();
}

Vector rotate(const Vector &v, ldb tcos, ldb tsin) {
    return Vector(v.x * tcos - v.y * tsin, v.x * tsin + v.y * tcos);
}
Vector rotate(const Vector &v, ldb ang) {
    return rotate(v, cosl(ang), sinl(ang));
}

struct Line {
    Vector o, v;
    Line(void) {}
    Line(const Vector &_o, const Vector &_v): o(_o), v(_v) {}
    bool con(const Vector &p) const {
        return sgn(cross(p - o, v)) == 0;
    }
};
struct Seg {
    Vector a, b;
    Seg(void) {}
    Seg(const Vector &_a, const Vector &_b): a(_a), b(_b) {}
    operator Line(void) const {
        return Line(a, b - a);
    }
    bool con(const Vector &p) const {
        return sgn(cross(p - a, b - a)) == 0 && sgn(dot(p - a, b - a)) >= 0 && sgn(dot(p - b, a - b)) >= 0;
    }
    bool _twoside(const Seg &oth) const {
        int x = sgn(cross(oth.a - b, a - b));

        if (x == 0)
            return 1;

        int y = sgn(cross(oth.b - b, a - b));

        if (y == 0)
            return 1;

        return x != y;
    }
};

Line make_Line(const Vector &p, const Vector &q) {
    return Line(p, q - p);
}
pair<Vector, bool> inter(const Line &a, const Line &b) {
    ldb k = cross(a.v, b.v);

    if (!sgn(k))
        return {a.o, 0};

    return {a.o + a.v *(cross(b.o - a.o, b.v) / k), 1};
}
bool hasinter(const Seg &a, const Seg &b) {
    return a._twoside(b) && b._twoside(a);
}
pair<Vector, bool> inter(const Seg &a, const Seg &b) {
    if (!hasinter(a, b))
        return {a.a, 0};
    else
        return inter(Line(a), Line(b));
}

struct Halfplane: Line {
    ldb ang;
    Halfplane(void) {}
    Halfplane(const Line &_a, const ldb _ang): Line(_a), ang(_ang) {}
    Halfplane(const Line &_a): Line(_a), ang(v.ang()) {}
    int con(const Vector &p) const {
        return sgn(cross(v, p - o));
    }
    bool operator < (const Halfplane &oth) const {
        if (sgn(ang - oth.ang) != 0)
            return ang < oth.ang;
        else
            return oth.con(o) > 0;
    }
};

vector<Vector> hp_intersection(vector<Halfplane> h) {
    Vector base[] = {Vector(-1e5, -1e5), Vector(1e5, -1e5), Vector(1e5, 1e5), Vector(-1e5, 1e5)};

    for (int i = 0; i < 4; ++i)
        h.emplace_back(make_Line(base[i], base[(i + 1) & 3]));

    vector<Halfplane> q(h.size());
    vector<Vector> qq(h.size());
    int hd = 0, tl = -1;

    sort(h.begin(), h.end());

    for (int i = 0; i < (int)h.size(); ++i)
        if (i == 0 || sgn(h[i].ang - h[i - 1].ang) != 0) {
            while (tl - hd + 1 >= 2 && h[i].con(qq[tl - 1]) <= 0)
                --tl;

            while (tl - hd + 1 >= 2 && h[i].con(qq[hd]) <= 0)
                ++hd;

            if (hd <= tl)
                qq[tl] = inter(h[i], q[tl]).first;

            q[++tl] = h[i];
        }

    while (tl - hd + 1 >= 3 && q[hd].con(qq[tl - 1]) <= 0)
        --tl;

    if (tl - hd + 1 < 3)
        return {};

    qq[tl] = inter(q[hd], q[tl]).first;

    qq.erase(qq.begin(), qq.begin() + hd);

    qq.resize(tl - hd + 1);

    return qq;
}

Vector p[MAXN];

int main(void) {
    int n;
    scanf("%d", &n);

    for (int i = 1; i <= n; ++i) {
        int x, y;
        scanf("%d%d", &x, &y);
        p[i] = Vector(x, y);
    }

    p[0] = p[n];
    p[n + 1] = p[1];
    static Seg seg[MAXN];

    for (int i = 1; i <= n; ++i)
        seg[i] = Seg(p[i], p[i + 1]);

    auto con = [&](Vector o) -> bool {
        for (int i = 1; i <= n; ++i)
            if (seg[i].con(o))
                return 1;

        Vector v(0, 1e6);
        v = rotate(v, rndang(rnd));
        Seg l(o, o + v);
        int res = 0;

        for (int i = 1; i <= n; ++i)
            res ^= hasinter(l, seg[i]);

        return res;
    };

    ldb ans = 0;

    for (int rt = 1; rt <= n; ++rt) {
        vector<Halfplane> vec;

        for (int i = 1; i <= n; ++i)
            if (i != rt) {
                auto o = (p[i] + p[rt]) / 2, v = p[rt] - p[i];
                swap(v.x, v.y);
                v.y *= -1;
                vec.emplace_back(Line(o, v));
            }

        auto h = hp_intersection(vec);

        vector<Seg> hl(h.size());

        for (int i = 0; i < (int)h.size(); ++i)
            hl[i] = Seg(h[i], h[(i + 1) % (int)h.size()]);

        for (auto t : h)
            if (con(t))
                ans = max(ans, dist(t, p[rt]));

        for (int i = 1; i <= n; ++i)
            for (auto l : hl) {
                Vector cur;
                bool ok;
                tie(cur, ok) = inter(seg[i], l);

                if (ok)
                    ans = max(ans, dist(cur, p[rt]));
            }
    }

    printf("%.20lf", (double)ans);
    return 0;
}