#include <cstdio>
#include <algorithm>
#include <cmath>

const int N = 100 + 5;
const double eps = 1e-8;

struct Vertice {
	double x, y;
	void set_point(double x_, double y_) { x = x_, y = y_; }
	void set_line(int y_) { x = 205, y = y_; }
	bool line() const { return x > 204; }
};
double distance(const Vertice &lhs, const Vertice &rhs) {
	if(!lhs.line() && !rhs.line())
		#define sq(x) ((x) * (x))
		return std::sqrt(sq(lhs.x - rhs.x) + sq(lhs.y - rhs.y));
		#undef sq
	else if(lhs.line() && rhs.line()) return std::abs(lhs.y - rhs.y);
	else return std::abs(lhs.y - rhs.y);
}

Vertice a[N];
int n;

int fa[N];
void init() { for(int i = 1; i <= n + 2; i++) fa[i] = i; }
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

bool check(double x) {
	init();
	for(int i = 1; i <= n + 2; i++)
		for(int j = 1; j <= n + 2; j++)
			if(i != j && x - distance(a[i], a[j]) > eps) {
				int x = find(i), y = find(j);
				if(x != y) fa[x] = y;
			}
	// std::printf("check %lf\n", x);
	if(find(1) == find(2)) return false;
	else return true;
}

int main() {
	std::scanf("%d", &n);
	a[1].set_line(100);
	a[2].set_line(-100);
	for(int i = 3; i <= n + 2; i++) {
		double x, y;
		std::scanf("%lf%lf", &x, &y);
		a[i].set_point(x, y);
	}
	// for(int i = 1; i <= n + 2; i++)
	// 	for(int j = 1; j <= n + 2; j++) {
	// 		if(i < 3) std::printf("Line[%d]\t<-->\t", (int)a[i].y);
	// 		else std::printf("(%.0lf, %.0lf) \t<-->\t", a[i].x, a[i].y);
	// 		if(j < 3) std::printf("Line[%d]\t= ", (int)a[j].y);
	// 		else std::printf("(%.0lf, %.0lf)  \t= ", a[j].x, a[j].y);
	// 		std::printf("%.3lf\n", distance(a[i], a[j]));
	// 	}
	double l = 0, r = 200;
	while(r - l > eps) {
		double mid = (l + r) / 2;
		if(check(mid * 2)) l = mid;
		else r = mid;
	}
	std::printf("%.5lf", l);
	return 0;
}
#include <bits/stdc++.h>

using namespace std;

typedef long long int ll;
typedef pair<ll, ll> pll;
typedef pair<double, ll> pdl;

#define FOR(i, n, m) for(ll (i)=(m);(i)<(n);++(i))
#define REP(i, n) FOR(i,n,0)
#define OF64 std::setprecision(40)

const ll MOD = 1000000007;
const ll INF = (ll) 1e15;

ll N;
pll A[105];

struct UnionFind {
    UnionFind(int n) {
        rank.assign(n, 0);
        parent.resize(n);
        for (int i = 0; i < n; ++i) {
            parent[i] = i;
        }
    }

    int find(int x) {
        if (x == parent[x])
            return x;
        return parent[x] = find(parent[x]);
    }

    bool same(int x, int y) {
        return find(x) == find(y);
    }

    void unit(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y)
            return;

        if (rank[x] < rank[y]) {
            parent[x] = y;
        }
        else {
            parent[y] = x;
            if (rank[x] == rank[y])
                rank[x]++;
        }
    }

    vector<int> rank;
    vector<int> parent;
};

double len(pll a, pll b) {
    double x = a.first - b.first;
    double y = a.second - b.second;
    return sqrt(x * x + y * y);
}

bool check(double r) {
    UnionFind uf(N + 2);

    REP(i, N) {
        FOR(j, N, i + 1) {
            if (len(A[i], A[j]) < 2 * r)
                uf.unit(i, j);
        }
    }

    REP(i, N) {
        if (100 - A[i].second < 2 * r)
            uf.unit(N, i);
        if (A[i].second + 100 < 2 * r)
            uf.unit(N + 1, i);
    }

    return !uf.same(N, N + 1);
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cin >> N;
    REP(i, N) {
        cin >> A[i].first >> A[i].second;
    }

    double ok = 0, ng = 101;
    REP(_, 100) {
        double mid = (ok + ng) * 0.5;
        if (check(mid))
            ok = mid;
        else
            ng = mid;
    }

    cout << OF64 << ok << endl;
}