#include <bits/stdc++.h>
using std::cin;
using std::cout;
using ll = long long;
using u64 = unsigned long long;
using db = double;
const db eps = 1e-4;
const db pi = std::acos(-1);
std::mt19937 gen;


db sgn(db x, db eps) {
    return x < -eps ? -1 : x > eps;
}
db sgn(db x) {
    return x < -eps ? -1 : x > eps;
}
db eq(db x, db y) {
    return !sgn(x - y);
}
struct vec2 {
    db x, y;
    db abs() const {
        return std::sqrt(x * x + y * y);
    }
};
vec2 r90(vec2 x) {
    return {-x.y, x.x};
}
vec2 operator + (vec2 x, vec2 y) {
    return {x.x + y.x, x.y + y.y};
}
vec2 operator - (vec2 x, vec2 y) {
    return {x.x - y.x, x.y - y.y};
}
vec2 operator / (vec2 x, db y) {
    return {x.x / y, x.y / y};
}
vec2 operator * (vec2 x, db y) {
    return {x.x * y, x.y * y};
}
db operator * (vec2 x, vec2 y) {
    return x.x * y.y - x.y * y.x;
}
db operator % (vec2 x, vec2 y) {
    return x.x * y.x + x.y * y.y;
}

struct line : vec2 {
    db z;
    line() = default;
    line(db a, db b, db c) : vec2{a, b}, z(c) {}
    line(vec2 a, vec2 b) : vec2(r90(b - a)), z(a * b) { }
    db operator()(vec2 a) const {
        return a % vec2(*this) + z;
    }
    line perp() const {
        return {y, -x, 0};    // 垂直
    }
    line para(vec2 o) {
        return {x, y, z - (*this)(o)};    // 平行
    }
};
vec2 operator & (line x, line y) {
    return vec2{vec2{x.z, x.y} *vec2{y.z, y.y}, vec2{x.x, x.z} *vec2{y.x, y.z}} / -(vec2(x) * vec2(y));
}
line bisector(vec2 x, vec2 y) {
    return line(y, x).perp().para((x + y) / 2);    // x 在半平面一侧
}
bool is_para(line x, line y) {
    return eq(vec2(x) * vec2(y), 0);    // 判断线平行
}
db det(line a, line b, line c) {
    vec2 A = a, B = b, C = c;
    return c.z * (A * B) + a.z * (B * C) + b.z * (C * A);
}
db check(line a, line b, line c) {
    return sgn(det(a, b, c), 0.5) * sgn(vec2(a) * vec2(b));
}
struct seg {
    vec2 x, y;
    seg(const vec2 &A, const vec2 &B) : x(A), y(B) {}
    bool onseg(const vec2 &o) const {
        return (o - x) % (o - y) < eps && std::fabs((o - x) * (o - y)) < eps;
    }
};
int contain(const std::vector<vec2> &a, vec2 o) {
    bool in = 0;

    for (int i = 0; i < (int) a.size(); ++i) {
        vec2 x = a[i] - o, y = a[(i + 1) % a.size()] - o;

        if (x.y > y.y)
            std::swap(x, y);

        if (x.y <= eps && y.y > eps && x * y < -eps)
            in ^= 1;

        if (std::fabs(x * y) < eps && x % y < eps)
            return 2; // 在线段上，看情况改
    }

    return in;
}
std::vector<line> cut(const std::vector<line> &o, line l) {
    std::vector<line> res;
    int n = size(o);

    for (int i = 0; i < n; ++i) {
        line a = o[i], b = o[(i + 1) % n], c = o[(i + 2) % n];
        int va = check(a, b, l), vb = check(b, c, l);

        //  assert(check(a, b, c) != 0);
        if (va > 0 || vb > 0 || (va == 0 && vb == 0)) {
            res.push_back(b);
        }

        if (va >= 0 && vb < 0) {
            res.push_back(l);
        }
    }

    return res;
}
std::vector<std::vector<line>> voronoi(std::vector<vec2> p) {
    int n = p.size();
    auto b = p;
    shuffle(b.begin(), b.end(), gen);
    const db V = 3e4;
    std::vector<std::vector<line>> a(n, {
        {V, 0, V * V}, {0, V, V * V},
        {-V, 0, V * V}, {0, -V, V * V},
    });

    for (int i = 0; i < n; ++i) {
        for (vec2 x : b)
            if ((x - p[i]).abs() > eps) {
                a[i] = cut(a[i], bisector(p[i], x));
            }
    }

    return a;
}
int main() {
    std::ios::sync_with_stdio(false), cin.tie(0);
    int n;
    cin >> n;
    std::vector<vec2> a(n);

    for (int i = 0; i < n; ++i) {
        cin >> a[i].x >> a[i].y;
    }

    auto vd = voronoi(a);
    db ans = 0;

    for (int i = 0; i < n; ++i) {
        auto v = vd[i];
        int m = v.size();
        std::vector<vec2> o(m);

        for (int j = 0; j < m; ++j) {
            o[j] = v[j] & v[(j + 1) % m];
        }

        for (auto x : o) {
            if (contain(a, x)) {
                ans = std::max(ans, (x - a[i]).abs());
            }
        }

        for (int j = 0; j < m; ++j) {
            seg x = {o[j], o[(j + 1) % m]};

            for (int k = 0; k < n; ++k) {
                seg y = {a[k], a[(k + 1) % n]};
                line X(x.x, x.y);
                line Y(y.x, y.y);

                if (is_para(X, Y))
                    continue;

                vec2 z = X & Y;

                if (x.onseg(z) && y.onseg(z))
                    ans = std::max(ans, (z - a[i]).abs());
            }
        }
    }

    printf("%.9lf\n", ans);
}