#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int ll

#define REP(i,n) for(int i=0;i<n;++i)
#define ALL(name) name.begin(),name.end()
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
#  define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#  define DBG(fmt, ...)
#endif

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 100010

// 最小包含円
// 点集合 を内部または円周上に全て含む、半径最小の円を求める。
// vector< complex<double> > の begin を left に、 end を right に与えると、
// 中心の座標を first(complex<double>) に入れ、 半径の二乗を second(double) に入れて返却する。
template< class iter >
std::pair< complex< double >, double > MinBall(iter left, iter right, int seed = 1333) {

    const int n = right - left;

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

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

    iter ps = left;
    using circle = std::pair< complex< double >, double >;

    auto make_circle_3 = [](const complex< double > &a, const complex< double > &b, const complex< double > &c) -> circle {

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

        double A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b);
        double S = cross(b - a, c - a);
        complex< double > p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) / (4 * S * S);
        double r2 = std::norm(p - a);
        return {p, r2};
    };

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

    auto in_circle = [](const complex< double > &a, const circle &c) -> bool {
        const double eps = 1e-10;
        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)) {
            // MiniDiscWithcomplex<double>oint
            c = make_circle_2(ps[0], ps[i]);
            for(int j = 1; j < i; ++j) {
                if(!in_circle(ps[j], c)) {
                    // MiniDiscWith2complex<double>oints
                    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;
}

signed main() {
    cin.tie(0); cout.tie(0);
    ios::sync_with_stdio(false);

    int N;
    vector< complex< double > > XY;

    cin >> N;
    REP(i, N) {
        double x, y;
        cin >> x >> y;
        XY.push_back( complex< double >(x, y) );
    }

    double r = sqrt(MinBall(XY.begin(), XY.end()).second);
    printf("%.7f\n", r);

    return 0;
}


Measured memory_bytes: 256