#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<pii,int> piii;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vii;
typedef vector<piii> viii;
template <class T > T amax(T _a, T _b ){	return _a > _b ? _a : _b;}
template <class T > T amin(T _a, T _b ){	return _a < _b ? _a : _b;}
template <class T > T gcd(T _a, T _b ){	T t; while(_b){	t = _b;	_b = _a%_b;_a = t; } return _a;}
#define M 1000000007
template <class T > T apow(T b,T p){ T r=1; while(p>0){if((p%2)==1)r=(r*b)%M; b=(b*b)%M;p/=2;}return r;}
#define pb push_back
#define mp make_pair
#define sz(v) (int)v.size()
#define all(c) c.begin(), c.end()
#define L printf("\n")
#define rep(i,n) for(int i = 0; i < n; i++)
#define rea(i,l,r) for(int i = l; i <= r; i++)
#define red(i,r,l) for(int i = r; i >= l; i--)
#define x first
#define y second
const int N = 5e2+1;
int n,m;
typedef pair<ld,ld> pld;
pld  pip[N],p[N];
ld _dist[N][N];
ld dist(pld a,pld b){ return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);}
pld gc;
ld getRadius(int p1,int p2,int p3){
    ld m11,m12,m13,m14;
    m11 = p[p1].x*(p[p2].y-p[p3].y)-p[p1].y*(p[p2].x-p[p3].x)+p[p2].x*p[p3].y-p[p2].y*p[p3].x;
    if(m11 != 0){
        ld s1 = p[p1].x*p[p1].x+p[p1].y*p[p1].y;
        ld s2 = p[p2].x*p[p2].x+p[p2].y*p[p2].y;
        ld s3 = p[p3].x*p[p3].x+p[p3].y*p[p3].y;
        m12 = s1*(p[p2].y-p[p3].y)-p[p1].y*(s2-s3)+s2*p[p3].y-s3*p[p2].y;
        m13 = s1*(p[p2].x-p[p3].x)-p[p1].x*(s2-s3)+s2*p[p3].x-s3*p[p2].x;
        m14 = s1*(p[p2].x*p[p3].y-p[p2].y*p[p3].x)-p[p1].x*(s2*p[p3].y-s3*p[p2].y)+p[p1].y*(s2*p[p3].x-s3*p[p2].x);
        gc.x = m12/m11;        gc.y = m13/m11;
        gc.x/=2;         gc.y/=-2;
        return (gc.x*gc.x+gc.y*gc.y+(m14/m11));
    }
    else return 1000000000000;
}
ld adist[N],_ad;
bool check(ld r){
    int cnt = 0;
    _ad = r;
    rep(i,n){
        if(dist(gc,p[i]) <= r + 1e-4) cnt++;
        if(cnt >= m)return true;
    }
    return false;
}

void preProcess(){
    rep(i,n){
        _dist[i][i] = 0;
        rea(j,i+1,n)
            _dist[i][j] = _dist[j][i] = dist(p[i],p[j]);
    }
}
bool cmp(pld a,pld b){
    return a.x < b.x;
}
#define pild pair<int , ld> 
bool _fxn(pild a,pild b){
    return a.second < b.second;
}
void output(){
    rep(i,n)scanf("%lf%lf",&pip[i].x,&pip[i].y);
    sort(pip,pip+n,cmp);
    
    vector< pair<int , ld > > newd;
    for(int index =0; index < n;index++){
        newd.pb({index,dist(pip[0],pip[index])});
    }
    sort(all(newd),_fxn);
    for(int index =0; index < n; index++){
        int k = newd[index].first;
        p[index].x = pip[k].x; p[index].y  = pip[k].y;
    }
    preProcess();
    ld r = 10000000000000;
    if(n == 1||m == 1) r = 0;
    else if(n == 2) r = _dist[0][1]/4;
    else if(m == 2){
        rep(i,n)
            rea(j,i+1,n-1)
                if(_dist[i][j]+1e-12 < 4*r) r = _dist[i][j]/4;
    }
    else {
        ld _d2 = 10000000000000; 
        rep(i,n){
            rep(j,n){
                adist[j] = _dist[i][j];
            }
            sort(adist,adist+n);
            if(_d2 > adist[m-1])_d2 = adist[m-1];
        }
        ld cur;
        rep(i,n)
            rea(j,i+1,n-1){
                    cur = _dist[i][j];
                    cur /= 4;
                    gc.x = (p[i].x+p[j].x)/2;
                    gc.y = (p[i].y+p[j].y)/2;
                    if(cur < r) if(check(cur))r = _ad;
            }
        rep(i,n)
            rea(j,i+1,n-1)
                if(_dist[i][j] < 4*r)
                    rea(k,j+1,n-1)
                        if(_dist[i][k] < 4*r && _dist[j][k] < 4*r){
                            cur = getRadius(i,j,k);
                            if(_d2/4 < cur &&  cur < _d2 && cur+1e-12 < r) if(check(cur))r = _ad;
                        }
    }
    r = sqrt(r);
    printf("%.7lf\n",r);
}
int main(){
    scanf("%d",&n);m=n;    output();
    return 0;
}

Measured memory_bytes: 512