#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 998244353;
using graph = vector<vector<int>>;

bool can_reach(const graph &g, const int s, const int t, vector<bool> &visited){
    if(s==t)return true;
    if(!visited[s]){
        visited[s] = true;
        for(const auto u: g[s]){
            if(can_reach(g, u, t, visited)){
                return true;
            }
        }
    }
    return false;
}

struct Point{
    int x;
    int y;
};

double distance(const Point &p, const Point &q){
    return sqrt((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}

int main()
{
    int n;
    cin >> n;
    vector<Point> vp;
    for(int i=0; i<n; ++i){
        int x, y;
        cin >> x >> y;
        vp.push_back({x, y});
    }
    double thres_min = 1e-5, thres_max = 100.0;
    while(thres_max - thres_min > 1e-6){
        double thres = (thres_min + thres_max) / 2.0;
        auto g = graph(n+2);
        for(int i=0; i<n; ++i){
            for(int j=i+1; j<n; ++j){
                if(distance(vp[i], vp[j]) < 2*thres){
                    g[i].push_back(j);
                    g[j].push_back(i);
                }
            }
            //上下端
            if(vp[i].y < -100 + 2 * thres){
                g[i].push_back(n);
                g[n].push_back(i);
            }
            if(vp[i].y > 100 - 2 * thres){
                g[i].push_back(n+1);
                g[n+1].push_back(i);
            }
        }
        auto visited = vector<bool>(n+2, false);
        if(can_reach(g, n, n+1, visited)){
            thres_max = thres;
        }else{
            thres_min = thres;
        }
    }
    printf("%1.18f\n", (thres_min + thres_max) / 2.0);
    return 0;
}
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i,j,k) for(int (i)=(j);(i)<(int)(k);++(i))
#define rep(i,j) FOR(i,0,j)
#define each(x,y) for(auto &(x):(y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(),(x).end()
#define debug(x) cout<<#x<<": "<<(x)<<endl
#define smax(x,y) (x)=max((x),(y))
#define smin(x,y) (x)=min((x),(y))
#define MEM(x,y) memset((x),(y),sizeof (x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;

class UnionFind {
    int cnt;
    vector<int> par, rank, size;
public:
    UnionFind() {}
    UnionFind(int _n) :cnt(_n), par(_n), rank(_n), size(_n, 1) {
        for (int i = 0; i<_n; ++i) par[i] = i;
    }
    int find(int k) {
        return (k == par[k]) ? k : (par[k] = find(par[k]));
    }
    int operator[](int k) {
        return find(k);
    }
    int getSize(int k) {
        return size[find(k)];
    }
    void unite(int x, int y) {
        x = find(x); y = find(y);
        if (x == y) return;
        --cnt;
        if (rank[x] < rank[y]) {
            par[x] = y;
            size[y] += size[x];
        } else {
            par[y] = x;
            size[x] += size[y];
            if (rank[y] == rank[x]) ++rank[x];
        }
    }
    int count() {
        return cnt;
    }
};

void solve() {
    int N;
    cin >> N;

    vi X(N), Y(N);
    rep(i, N)cin >> X[i] >> Y[i];
    double ok = 0, ng = 200;
    rep(ITER, 60) {
        UnionFind uf(N + 2);
        double d = (ok + ng) / 2;
        rep(i, N) {
            if (100 - Y[i] < d)uf.unite(i, N);
            if (Y[i] + 100 < d)uf.unite(i, N + 1);
            rep(j, i) {
                if (hypot(X[i] - X[j], Y[i] - Y[j]) < d)uf.unite(i, j);
            }
        }
        (uf[N] == uf[N + 1] ? ng : ok) = d;
    }
    cout << ok/2 << endl;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << fixed << setprecision(15);
	solve();
	return 0;
}