#include <bits/stdc++.h>
using namespace std;
 
#define int long long 
#define pb push_back
#define S second
#define F first
#define f(i,n) for(int i=0;i<n;i++)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define vi vector<int>
#define pii pair<int,int>

const int N = 105;
int n;
pair<double,double> a[N];
pii dsu[N];

int find(int x)
{
    if(dsu[x].F == x) return x;
    return dsu[x].F = find(dsu[x].F);
}

void merge(int x,int y)
{
    int p = find(x);
    int q = find(y);
    
    if(p == q) return;
    
    if(dsu[p].S > dsu[q].S) swap(p,q);
    
    dsu[q].S+=dsu[p].S;
    dsu[p].F = dsu[q].F;
}

//n is upper
//n+1 is lower

double dis(pair<double,double> x,pair<double,double> y)
{
   return sqrt( ((x.F - y.F)*(x.F - y.F)) + ((x.S - y.S)*(x.S - y.S)) );   
}

bool check(double r)
{
    f(i,n+2) dsu[i] = {i,1};
    
    f(i,n) f(j,n)
        if(dis(a[i],a[j]) <= r + r) merge(i,j);
    
    f(i,n) if(100 - a[i].S <= r + r) merge(i,n);
    f(i,n) if(a[i].S + 100 <= r + r) merge(i,n+1); 
        
    return find(n) != find(n+1);
}

signed main()
{
    fast;
    
   cin >> n;
    
   f(i,n) cin >> a[i].F >> a[i].S;
    
   vector<double> go;
    
   f(i,n) f(j,n) go.pb(dis(a[i],a[j])/2);
   f(i,n) go.pb((100 - a[i].S)/2);
   f(i,n) go.pb((a[i].S + 100)/2);
    
   double res = 0; 
    
   for(auto x : go) 
       if(check(x - 1e-9) || check(x + 1e-9)) res = max(res,x);
   
   cout << fixed << setprecision(4) << res;
}
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <deque>
#include <set>
#include <iomanip>
#include <utility>
typedef long long ll;
typedef long double ld;
using namespace std;

int x[110], y[110];

struct UnionFind{
    vector<int> data;
    UnionFind(ll sz){
        data.assign(sz, -1);
    }
    int find(int p){
        if(data[p]<0) return p;
        return data[p]=find(data[p]);
    }
    bool unite(int X, int Y){
        X=find(X), Y=find(Y);
        if(X==Y) return false;
        if(data[X]>data[Y]) swap(X, Y);
        data[X] += data[Y];
        data[Y]=X;
        return true;
    }
    ll size(int k){
        return -data[find(k)];
    }
};

int main() {
	int N;
	cin >> N;
	for(int i=0; i<N; ++i) cin >> x[i] >> y[i];
	vector<pair<int, pair<int, int>>> v;
	for(int i=0; i<N; ++i){
		for(int j=i+1; j<N; ++j){
			v.emplace_back(make_pair((x[j]-x[i])*(x[j]-x[i])+(y[j]-y[i])*(y[j]-y[i]), make_pair(i, j)));
		}
		v.emplace_back(make_pair((y[i]+100)*(y[i]+100), make_pair(i, N)));
		v.emplace_back(make_pair((y[i]-100)*(y[i]-100), make_pair(i, N+1)));
	}
	sort(v.begin(), v.end());
	UnionFind uf(N+2);
	int now=-1;
	while(uf.find(N)!=uf.find(N+1)){
		++now;
		uf.unite(v[now].second.first, v[now].second.second);
	}
	cout << setprecision(15) << pow(v[now].first, 0.5)*0.5 << endl;
	return 0;
}