#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define ep emplace
#define epb emplace_back
#define scll static_cast<long long> 
#define sz(x) static_cast<int>((x).size())
#define pfll(x) printf("%lld\n", x)
#define ci(x) cin >> x
#define ci2(x, y) cin >> x >> y
#define ci3(x, y, z) cin >> x >> y >> z
#define co(x) cout << x << endl
#define co2(x, y) cout << x << y << endl
#define co3(x, y, z) cout << x << y << z << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef priority_queue<int> PQ;
typedef priority_queue<int, vector<int>, greater<int>> PQG;
typedef priority_queue<P> PQP;
typedef priority_queue<P, vector<P>, greater<P>> PQPG;

const int MAX_N = 2e5, MOD = 1e9 + 7, INF = 1e9;
int n, x[100], y[100];

int par[MAX_N + 2], r[MAX_N + 2];

void init(int x) {
    for (int i = 0; i < x; i++) par[i] = i;
}

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

void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (r[x] < r[y]) par[x] = y;
    else {
        if (r[x] == r[y]) r[x]++;
        par[y] = x;
    }
}

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

int main() {
    ci(n);
    rep(i, n) ci2(x[i], y[i]);
    double l = 0.0, r = 100.0;
    rep(cnt, 200) {
        double mid = (l + r) / 2;
        init(n + 2);
        rep(i, n) {
            if (2 * mid >= 100 - y[i]) unite(i, n);
            if (2 * mid >= y[i] + 100) unite(i, n + 1);
            rep(j, i) {
                if (4 * mid * mid >= (x[i] - x[j]) * (x[i] - x[j])
                                  +  (y[i] - y[j]) * (y[i] - y[j])) {
                    unite(i, j);
                }
            }
        }
        if (same(n, n + 1)) r = mid;
        else l = mid;
    }
    printf("%5.15lf\n", l);
    return 0;
}

/**
 * Written by : Ujjawal Pabreja [cuber_coder]
 * Email : ujjawalpabreja99@gmail.com
*/
#include <bits/stdc++.h> 
using namespace std;
#define int long long
#define ll long long
#define ld long double
#define endl "\n"
const int mod = 1e9 + 7;
const int MAX = 2e5 + 1;

int n;
vector <pair <ld, ld>> a;
vector <int> Parent, Rank;

void init() {
    Parent.resize(n + 2);
    Rank.resize(n + 2);
    iota(Parent.begin(), Parent.end(), 0);
}

int Find(int v) {
    while (v != Parent[v]) {
        v = Parent[v];
    }
    return v;
}

void Union(int u, int v) {
    u = Find(u);
    v = Find(v);
    if (Rank[u] < Rank[v]) {
        Parent[u] = v;
    } else {
        Parent[v] = u;
        if (Rank[u] == Rank[v]) {
            Rank[u]++;
        }
    }
}

ld distance(pair <ld, ld> a, pair <ld, ld> b) {
    return (a.first - b.first) * (a.first - b.first) + (a.second - b.second) * (a.second - b.second);
}

bool possible(ld r) {
    init();
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (distance(a[i], a[j]) <= 4.0 * r * r) {
                Union(i, j);
            }
        }
    }
    for (int i = 1; i <= n; i++) {
        if (abs(a[i].second - 100) <= 2.0 * r) {
            Union(n + 1, i);
        }
        if (abs(a[i].second + 100) <= 2.0 * r) {
            Union(0, i);
        }
    }
    return Find(0) != Find(n + 1);
}

void Solve() {
    cin >> n;
    a.resize(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i].first >> a[i].second;
    }
    sort(a.begin() + 1, a.end());
    ld hi = 100, lo = 0, ans;
    ll itr = 100;
    while (itr--) {
        ld mid = lo + (hi - lo) / 2;
        if (possible(mid)) {
            lo = mid + 1;
            ans = mid;
        } else {
            hi = mid - 1;
        }
    }
    cout << fixed << setprecision(20) << ans << endl;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int testcases = 1;
    // cin >> testcases;

    while (testcases--) {
        Solve();
    }
}