#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <utility>
#include <deque>
#include <stack>
#include <bitset>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<int,ll> pil;
typedef pair<ll,int> pli;
#define rep(i,n) for (int i=0;i<n;++i)
#define REP(i,n) for (int i=1;i<=n;++i)
#define all(x) x.begin(),x.end()
#define mp make_pair
#define pb push_back
#define pf push_front
#define F first
#define S second
#define RI(x) scanf("%d",&x)
#define RII(x,y) scanf("%d%d",&x,&y)

int n;
int x[105],y[105];
vector<int> G[105];
bool vis[105];
inline void dfs(int u){
	vis[u]=1;
	for (int i=0;i<G[u].size();++i) if (!vis[G[u][i]]) dfs(G[u][i]);
}
int main(){
	ios::sync_with_stdio(false);
	cin>>n;
	// lower bound line: 0    upper bound line: n+1
	REP(i,n) cin>>x[i]>>y[i];
	int l=0,r=1e8;// l:ok  r:bad
	// multiplied by 1e6.
	while(r-l>1){
		int m=l+r>>1;
		rep(i,n+2) G[i].clear();
		REP(i,n) if ((y[i]+100)*1e6<m*2) G[0].pb(i);
		REP(i,n) if ((100-y[i])*1e6<m*2) G[i].pb(n+1);
		for (int i=1;i<n;++i) for (int j=i+1;j<=n;++j)
			if ((ll)((x[i]-x[j])*(x[i]-x[j])+((y[i]-y[j])*(y[i]-y[j])))*1e6*1e6 < (ll)m*m*4) G[i].pb(j),G[j].pb(i);
		memset(vis,0,sizeof(vis));
		dfs(0);
		if (vis[n+1]) r=m;
		else l=m;
	}
	double x=(double)l/1e6;
	printf("%0.5lf",x);
	return 0; 
}
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <numeric>
#include <utility>
#include <tuple>

#define REP(i, a, b) for (int i = int(a); i < int(b); i++)
using namespace std;
using ll = long long int;
using P = pair<ll, ll>;

// clang-format off
#ifdef _DEBUG_
#define dump(...) do{ cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; PPPPP(__VA_ARGS__); cerr << endl; } while(false)
template<typename T> void PPPPP(T t) { cerr << t; }
template<typename T, typename... S> void PPPPP(T t, S... s) { cerr << t << ", "; PPPPP(s...); }
#else
#define dump(...) do{ } while(false)
#endif
template<typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template<typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template<typename T> bool chmin(T &a, T b) { if (a > b) {a = b; return true; } return false; }
template<typename T> bool chmax(T &a, T b) { if (a < b) {a = b; return true; } return false; }
template<typename T> void print(T a) { cout << a << '\n'; }
template<typename T, typename... Ts> void print(T a, Ts... ts) { cout << a << ' '; print(ts...); }
template<typename T> istream &operator,(istream &in, T &t) { return in >> t; }
// clang-format on

class UnionFind {
public:
    vector<int> par;
    int N;
    UnionFind(int n) {
        par.resize(n, -1);
        N = n;
    }
    int Find(int n) {
        return par[n] < 0 ? n : par[n] = Find(par[n]);
    }
    bool Union(int x, int y) {
        x = Find(x);
        y = Find(y);
        if (x == y) return false;
        if (-par[x] > -par[y]) swap(x, y);
        par[y] += par[x];
        par[x] = y;
        N--;
        return true;
    }
    bool Same(int x, int y) {
        return Find(x) == Find(y);
    }
    int size(int x) {
        return -par[Find(x)];
    }
    int size() {
        return N;
    }
};

#include <iomanip>

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n;
    cin, n;
    vector<int> x(n), y(n);
    REP(i, 0, n) {
        cin, x[i], y[i];
    }
    double l = 0, r = 100;
    double ans = 0;
    while (abs(r - l) >= 1e-9) {
        UnionFind uf(n + 2);
        double mid = (l + r) / 2;
        REP(i, 0, n) {
            REP(j, 0, n) {
                if ((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) < 4 * mid * mid) {
                    uf.Union(i, j);
                }
            }
            if (y[i] + mid > 100 - mid) {
                uf.Union(i, n);
            }
            if (y[i] - mid < -100 + mid) {
                uf.Union(i, n + 1);
            }
        }
        dump(mid, uf.Same(n, n + 1));
        if (uf.Same(n, n + 1)) {
            r = mid;
        } else {
            l = mid;
            ans = mid;
        }
    }
    cout << fixed << setprecision(15) << ans << endl;
    return 0;
}
