// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



using ll = long long;

const ll MOD = 1e9 + 7;

const ll INF = 1e18;



int main() {

    ll n, m, i, j;

    cin >> n;

    vector<pair<int, int>> v(n);

    double kyori = 0.000000;

    for(i = 0; i < n; i++) {

        double x, y;

        cin >> x >> y;

        v[i] = {x, y};

    }

    double mv_rate = 0.5;

    double max_dist = 0.0;

    double xsv = 0.0;

    double ysv = 0.0;

    double cx = 0.0;

    double cy = 0.0;

    double CONVRGV = 1.0e-9;

    int k = 0;

    bool cvgflg = false;

    while(cvgflg == false) {

        for(int x = 0; x < 100; x++) {

            max_dist = 0.0;

            for(i = 0; i < n; i++) {

                double dist = (v[i].first - cx) * (v[i].first - cx) + (v[i].second - cy) * (v[i].second - cy);

                dist = sqrt(dist);

                if(dist > max_dist) {

                    max_dist = dist;

                    k = i;

                }

            }

            cx += (v[k].first - xsv) * mv_rate;

            cy += (v[k].second - ysv) * mv_rate;

            if(sqrt((cx - xsv) * (cx - xsv) + (cy - ysv) * (cy - ysv)) <= CONVRGV) {

                cx = xsv;

                cy = ysv;

                cvgflg = true;

            }

            xsv = cx;

            ysv = cy;

        }

        mv_rate /= 2.0;

    }

    printf("%.12f\n", max_dist);

    return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



using namespace std;



using ll = long long;

const ll MOD = 1e9 + 7;

const ll INF = 1e18;

#define rep(i, n) for(int i = 0; i < (int)(n); i++)

#define all(c) begin(c), end(c)

#define dump(x) cerr << __LINE__ << ":\t" #x " = " << x << endl



using ld = double;

using P = complex<ld>;

using G = vector<P>;

const ld pi = acos(-1);

const ld eps = 1e-10;

const ld inf = 1e12;



ld cross(const P &a, const P &b) { return a.real() * b.imag() - a.imag() * b.real(); }

ld dot(const P &a, const P &b) { return a.real() * b.real() + a.imag() * b.imag(); }



using C = pair<ld, P>;

#define rad first

#define pnt second



C smallest_enclosing_disc(vector<P> ps) {

    auto c3 = [](const P &a, const P &b, const P &c) {

        ld A = norm(b - c);

        ld B = norm(c - a);

        ld C = norm(a - b);

        ld S = abs(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 r = abs(p - a);

        return make_pair(r, p);

    };



    auto c2 = [](const P &a, const P &b) {

        P c = (a + b) / (ld)2;

        ld r = abs(a - c);

        return make_pair(r, c);

    };



    auto in_circle = [](const P &a, const C &c) {

        return norm(a - c.pnt) <= c.rad * c.rad + eps;

    };



    int n = ps.size();

    random_shuffle(ps.begin(), ps.end());

    C c = c2(ps[0], ps[1]);

    for(int i = 2; i < n; ++i) {

        if(!in_circle(ps[i], c)) {

            c = c2(ps[0], ps[i]);

            for(int j = 1; j < i; ++j) {

                if(!in_circle(ps[j], c)) {

                    c = c2(ps[j], ps[i]);

                    for(int k = 0; k < j; ++k) {

                        if(!in_circle(ps[k], c)) {

                            c = c3(ps[i], ps[j], ps[k]);

                        }

                    }

                }

            }

        }

    }

    return c;

}



int main() {

    int n;

    cin >> n;

    vector<P> ps(n);

    for(int i = 0; i < n; ++i) {

        ld x, y;

        cin >> x >> y;

        ps[i] = P(x, y);

    }

    printf("%.12f\n",(double)smallest_enclosing_disc(ps).rad);

    return 0;

}

// Fastest known solution for this problem: