#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <algorithm>
#include <functional>
#include <iterator>
#include <locale>
#include <memory>
#include <stdexcept>
#include <utility>
#include <string>
#include <fstream>
#include <ios>
#include <iostream>
#include <iosfwd>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <complex>
#include <numeric>
#include <valarray>
#include <exception>
#include <limits>
#include <new>
#include <typeinfo>
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <climits>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdlib>
#include <cstddef>
#include <cstdarg>
#include <ctime>
#include <cstdio>
#include <cstring>
#include <cwchar>
#include <cwctype>
using namespace std;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
static const double PI2 = 8.0 * atan(1.0);
using ll = long long;
using ull = unsigned long long;

#define ALL(c) (c).begin(), (c).end()
#define CLEAR(v) memset(v,0,sizeof(v))
#define MP(a,b) make_pair((a),(b))
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ABS(a) ((a)>0?(a):-(a))
template<class T> T MIN(const T& a, const T& b) { return a < b ? a : b; }
template<class T> T MAX(const T& a, const T& b) { return a > b ? a : b; }
template<class T> void MIN_UPDATE(T& a, const T& b) { if (a > b) a = b; }
template<class T> void MAX_UPDATE(T& a, const T& b) { if (a < b) a = b; }

constexpr int mo = 1000000007;
int qp(int a,ll b){int ans=1;do{if(b&1)ans=1ll*ans*a%mo;a=1ll*a*a%mo;}while(b>>=1);return ans;}
int qp(int a,ll b,int mo){int ans=1;do{if(b&1)ans=1ll*ans*a%mo;a=1ll*a*a%mo;}while(b>>=1);return ans;}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};

typedef double number;
typedef valarray<number> point;
const int dim = 3;

number dot(const point& a, const point& b) {
    return (a * b).sum();
}
point cross(const point& a, const point& b) {
    return a.cshift(+1) * b.cshift(-1)
        - a.cshift(-1) * b.cshift(+1);
}
number dist2(const point& a, const point& b) {
    return dot(a - b, a - b);
}

struct min_ball {
    point center;
    number radius2;
    void add(const point& p) {
        ps.push_back(p);
    }
    void compile() {
        m = 0;
        center.resize(dim, 0);
        radius2 = -1;
        make_ball(ps.end());
    }
    template <class OUT>
    void support(OUT out) {
        copy(ps.begin(), supp_end, out);
    }
    min_ball() {
        for (int i = 0; i <= dim; ++i) {
            c[i].resize(dim, 0);
            v[i].resize(dim, 0);
        }
    }
private:
    list<point> ps;
    list<point>::iterator supp_end;
    int m;
    point v[dim + 1], c[dim + 1];
    number z[dim + 1], r[dim + 1];
    void pop() { --m; }
    void push(const point& p) {
        if (m == 0) {
            c[0] = p; r[0] = 0;
        }
        else {
            number e = dist2(p, c[m - 1]) - r[m - 1];
            point delta = p - c[0];
            v[m] = p - c[0];
            for (int i = 1; i < m; ++i)
                v[m] -= v[i] * dot(v[i], delta) / z[i];
            z[m] = dot(v[m], v[m]);
            c[m] = c[m - 1] + e * v[m] / z[m] / 2;
            r[m] = r[m - 1] + e * e / z[m] / 4;
        }
        center = c[m];
        radius2 = r[m]; ++m;
    }
    void make_ball(list<point>::iterator i) {
        supp_end = ps.begin();
        if (m == dim + 1) return;
        for (list<point>::iterator k = ps.begin(); k != i; ) {
            list<point>::iterator j = k++;
            if (dist2(*j, center) > radius2) {
                push(*j); make_ball(j); pop();
                move_to_front(j);
            }
        }
    }
    void move_to_front(list<point>::iterator j) {
        if (supp_end == j) ++supp_end;
        ps.splice(ps.begin(), ps, j);
    }
};

int main() {
	std::ios::sync_with_stdio(false);

	int N;
	cin >> N;
    min_ball m;
    REP(n, N) {
        double x, y;
        cin >> x >> y;
        point p;
        p.resize(2);
        p[0] = x;
        p[1] = y;
        m.add(p);
    }

    m.compile();

    printf("%.20f\n", sqrt(m.radius2));
}


Measured memory_bytes: 384