// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools

#include <bits/stdc++.h>

using namespace std;

using i64 = long long;

const i64 MOD = 1e9 + 7;
const i64 INF = i64(1e18) + 7;


template <typename T>
bool chmin(T& x, T y){
    if(x > y){
        x = y;
        return true;
    }
    return false;
}

template <typename T>
bool chmax(T& x, T y){
    if(x < y){
        x = y;
        return true;
    }
    return false;
}

using ld = long double;
using P = complex<ld>;
using circle = pair<P, ld>;
auto cross = [](const P& a, const P& b) { return a.real()*b.imag() - a.imag()*b.real(); };

const ld eps = 1e-12;

template <class iter>
std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
    const int n = right - left;

    assert(n >= 1);
    if (n == 1) {
        return {*left, ld(0)};
    }

    std::mt19937 mt(seed);
    std::shuffle(left, right, mt);
    // std::random_shuffle(left, right); // simple but deprecated

    iter ps = left;

    auto make_circle_3 = [](const P &a, const P &b, const P &c) -> circle {
        ld A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b),
                S = cross(b - a, c - a);
        P p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
        ld r2 = std::norm(p - a);
        return {p, r2};
    };

    auto make_circle_2 = [](const P &a, const P &b) -> circle {
        P c = (a + b) / (ld)2;
        ld r2 = std::norm(a - c);
        return {c, r2};
    };

    auto in_circle = [](const P &a, const circle &c) -> bool {
        return std::norm(a - c.first) <= c.second + eps;
    };

    circle c = make_circle_2(ps[0], ps[1]);

    // MiniDisc
    for (int i = 2; i < n; ++i) {
        if (!in_circle(ps[i], c)) {
            // MiniDiscWithPoint
            c = make_circle_2(ps[0], ps[i]);
            for (int j = 1; j < i; ++j) {
                if (!in_circle(ps[j], c)) {
                    // MiniDiscWith2Points
                    c = make_circle_2(ps[i], ps[j]);
                    for (int k = 0; k < j; ++k) {
                        if (!in_circle(ps[k], c)) {
                            c = make_circle_3(ps[i], ps[j], ps[k]);
                        }
                    }
                }
            }
        }
    }
    return c;
}


void solve(long long n, std::vector<long long> x, std::vector<long long> y){

    vector<complex<ld>> p;
    for(int i = 0; i < n; ++i)
        p.emplace_back(x[i], y[i]);
    auto res = min_ball(p.begin(), p.end());
    printf("%.20Lf\n", sqrt(res.second));
    /*
    auto f = [&](int aa, int bb, int cc) -> circle{
        P a(x[aa], y[aa]);
        P b(x[bb], y[bb]);
        P c(x[cc], y[cc]);
        ld A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b),
                S = cross(b - a, c - a);
        P p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
        ld r2 = std::norm(p - a);
        return make_pair(p, r2);
    };

    auto in_circle = [](P a, circle c) -> bool {
        return std::norm(a - c.first) <= c.second + (long double)(1e-12);
    };

    long double ans = INF;
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j)
            for(int k = 0; k < n; ++k)
                if(i != j && j != k && i != k){
                    auto ret = f(i, j, k);
                    bool fl = true;
                    for(int l = 0; l < n; ++l)
                        fl |= in_circle(P(x[l], y[l]), ret);
                    if(fl)
                        chmin(ans, ret.second);
                }
    */

}


signed main(){
    long long N;
    scanf("%lld",&N);
    std::vector<long long> x(N);
    std::vector<long long> y(N);
    for(int i = 0 ; i < N ; i++){
        scanf("%lld",&x[i]);
        scanf("%lld",&y[i]);
    }
    solve(N, std::move(x), std::move(y));
    return 0;
}


Measured memory_bytes: 384