#include <bits/stdc++.h>
#include <fstream>

using namespace std;
#define all(a)a.begin(),a.end()
using ll=long long;
const int INF = 1<<30;
const ll INFll =1LL<<62;
//const int mod= int(1e9)+7;
const int mod=998244353;
using P = pair<int,int>;
using Pl= pair<ll,ll>;
using ld=long double;
using V=vector<int>;
using Vl=vector<ll>;
using VV=vector<vector<int>>;
using VVl=vector<vector<ll>>;

ld d(P a, P b){
    return sqrt((a.first-b.first)*(a.first-b.first)+(a.second-b.second)*(a.second-b.second));
}
struct UnionFind{
    vector<int> d;
    UnionFind(int n=0):d(n,-1){}
    int root(int x){
        if(d[x]<0)return x;
        return d[x]=root(d[x]);
    }
    bool unite(int x,int y){
        x=root(x);y=root(y);
        if(x==y)return false;
        if(d[x]>d[y])swap(x,y);
        d[x]+=d[y];
        d[y]=x;
        return true;
    }
    bool same(int x,int y){return root(x)==root(y);}
    int usize(int x){return -d[root(x)];}
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;cin >>n;
    UnionFind uni(n+2);
    vector<P>pos(n);
    for (int i = 0; i < n; ++i) {
        cin >>pos[i].first>>pos[i].second;
    }
    vector<pair<ld,P>>g;
    for (int i = 0; i < n; ++i) {
        g.push_back({100-pos[i].second,{0,i+2}});
        g.push_back({pos[i].second+100,{1,i+2}});
    }
    for (int i = 0; i < n; ++i) {
        for (int j =i+1; j <n; ++j) {
            g.push_back({d(pos[i],pos[j]),{i+2,j+2}});
        }
    }
    sort(all(g));
    int m=g.size();
    ld r=0;
    for(auto e:g){
        ld dd=e.first;
        r=dd/2;
        uni.unite(e.second.first,e.second.second);
        if(uni.same(0,1))break;
    }
    cout <<setprecision(20)<<r<<"\n";
    return 0;
}
#include<bits/stdc++.h>
using namespace std;

int main() {
    int N;
    int ans=0, tmp, maxa=0, maxb=0, maxc=0, maxd=0, maxe=0, ai, bi, ci, di, ei;
    cin >> N;
    vector<int> a(N), b(N), c(N), d(N), e(N), m(5);

    for(int i=0; i<N; i++){
	cin >> a[i] >> b[i] >> c[i] >> d[i] >> e[i];
	if(maxa < a[i]){
	    maxa = a[i];
	    m[0] = i;
	}
	if(maxb < b[i]){
	    maxb = b[i];
	    m[1] = i;
	}

	if(maxc < c[i]){
	    maxc = c[i];
	    m[2] = i;
	}

	if(maxd < d[i]){
	    maxd = d[i];
	    m[3] = i;
	}

	if(maxe < e[i]){
	    maxe = e[i];
	    m[4] = i;
	}
    }

    for(int i=0; i<N; i++){
	for(int j=i+1; j<N; j++){
	    for(int k=0; k<5; k++){
		maxa = max(max(a[i], a[j]), a[m[k]]);
		maxb = max(max(b[i], b[j]), b[m[k]]);
		maxc = max(max(c[i], c[j]), c[m[k]]);
		maxd = max(max(d[i], d[j]), d[m[k]]);
		maxe = max(max(e[i], e[j]), e[m[k]]);

		tmp = min(min(min(min(maxa, maxb), maxc), maxd), maxe);
		ans = max(ans, tmp);
	    }
	}
    }





    // for(int i=0; i<N; i++){
    // 	if(a[i]<=ans || b[i]<=ans ||c[i]<=ans ||d[i]<=ans ||e[i]<=ans )
    // 	    continue;
    // 	for(int j=i+1; j<N; j++){
    // 	    if(a[j]<=ans || b[j]<=ans ||c[j]<=ans ||d[j]<=ans ||e[j]<=ans )
    // 		continue;

    // 	    for(int k=j+1; k<N; k++){
    // 		if(a[k]<=ans || b[k]<=ans ||c[k]<=ans ||d[k]<=ans ||e[k]<=ans )
    // 		    continue;

    // 		maxa = max(max(a[i], a[j]), a[k]);
    // 		maxb = max(max(b[i], b[j]), b[k]);
    // 		maxc = max(max(c[i], c[j]), c[k]);
    // 		maxd = max(max(d[i], d[j]), d[k]);
    // 		maxe = max(max(e[i], e[j]), e[k]);

    // 		tmp = min(min(min(min(maxa, maxb), maxc), maxd), maxe);
    // 		ans = max(ans, tmp);
    // 	    }
    // 	}
    // }
    cout << ans << endl;

}
