#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<pll> vpll;

void INX(){}
template<typename Head, typename... Tail>
void INX(Head&& head, Tail&&... tail)
{
    cin >> head;
    INX(forward<Tail>(tail)...);
}
void OUTX(){}
template<typename Head, typename... Tail>
void OUTX(Head&& head, Tail&&... tail)
{
    cout << head << endl;
    OUTX(forward<Tail>(tail)...);
}
//setprecision(10)

#define ADD emplace_back
#define MP make_pair
#define VVEC(type) vector<vector<type>>

struct mydistance
{
    ll index1;
    ll index2;
    ld dist;
};

class UnionFind
{
    private:
    vll parent;

    public:
    UnionFind(ll N)
    {
        parent.resize(N);
        for (ll i = 0; i < N; i++)
        {
            parent[i] = i;
        }
    }

    ll GetParent(ll x)
    {
        if(parent[x] == x)
        {
            return x;
        }
        else
        {
            return (parent[x] = GetParent(parent[x]));
        }
    }

    void Unite(ll x, ll y)
    {
        ll rx = GetParent(x);
        ll ry = GetParent(y);
        if(rx != ry)
        {
            parent[rx] = ry;
        }
    }

    bool IsUnited(ll x, ll y)
    {
        return GetParent(x) == GetParent(y);
    }
};

int main()
{
    ll N;
    INX(N);

    vector<pair<ld, ld>> kugi(N);
    for (ll i = 0; i < N; i++)
    {
        INX(kugi[i].first, kugi[i].second);
    }

    // calculate distances; i = N -> wall of y = -100, i = N + 1 -> wall of y = 100
    vector<mydistance> vd;
    for (ll i = 0; i < N + 1; i++)
    {
        for (ll j = i + 1; j <= N + 1; j++)
        {
            mydistance d = {0, 0, 0};
            d.index1 = i;
            d.index2 = j;

            if(i == N)
            {
                //if(j == N + 1) <- always true in this case
                d.dist = 200;
            }
            else if(j == N)
            {
                d.dist = kugi[i].second + 100;
            }
            else if(j == N + 1)
            {
                d.dist = 100 - kugi[i].second;
            }
            else
            {
                ld tmp1 = kugi[i].first - kugi[j].first;
                ld tmp2 = kugi[i].second - kugi[j].second;
                d.dist = sqrtl(tmp1 * tmp1 + tmp2 * tmp2);
            }

            vd.ADD(d);
        }
    }
    sort(vd.begin(), vd.end(), [](mydistance x, mydistance y){return x.dist < y.dist;});
    
    UnionFind uf(N + 2);
    for (ll i = 0; i < (ll)vd.size(); i++)
    {
        uf.Unite(vd[i].index1, vd[i].index2);
        if(uf.IsUnited(N, N + 1))
        {
            cout << setprecision(10) << (vd[i].dist / (ld)2.0) << endl;
            break;
        }
    }

    return 0;
}

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define deb(x)	cout << #x << " " << x << endl;

typedef long long int ll;
typedef pair<int, int> pi;
typedef pair<int, double> pid;

#define UP_Y 100
#define DOWN_Y -100

const double EPS = 0.00001;

double sq(int a) {
	return (double) a*a;
}

double dist(pi a, pi b) {
	return sqrt(sq(a.first-b.first) + sq(a.second-b.second));
}

double distUp(pi a) {
	return dist(make_pair(a.first, UP_Y), a);
}

double distDown(pi a) {
	return dist(make_pair(a.first, DOWN_Y), a);
}

bool can(double r, vector<vector<pid>> &g, int n) {
	// deb(r);

	double d = r+r;
	vector<bool> vis(n+2, false);
	queue<int> q;
	q.push(n);
	vis[n] = true;

	while (!q.empty()) {
		int popped = q.front();
		q.pop();

		for (auto e: g[popped]) {
			if (vis[e.first])
				continue;

			if (e.second >= d)
				continue;

			if (e.first == n+1)
				return false;

			q.push(e.first);
			vis[e.first] = true;
			// cout << "push " << e.first << endl;
		}
	}

	return true;
}

int main() {

	IOS

	int n;
	cin >> n;
	pi p[n];

	for (int i = 0; i < n; i++)
		cin >> p[i].first >> p[i].second;

	vector<vector<pid>> g(n+2);

	for (int i = 0; i < n; i++) {
		for (int j = i+1; j < n; j++) {
			double dsq = dist(p[i], p[j]);
			g[i].push_back({j, dsq});
			g[j].push_back({i, dsq});			
		}
	}

	for (int i = 0; i < n; i++) {
		double dist_up = distUp(p[i]);
		g[n].push_back({i, dist_up});
		g[i].push_back({n, dist_up});
	}

	for (int i = 0; i < n; i++) {
		double dist_down = distDown(p[i]);
		g[n+1].push_back({i, dist_down});
		g[i].push_back({n+1, dist_down});
	}


	// for (int i = 0; i < n+2; i++) {
	// 	cout << i << ": ";
	// 	for (auto x: g[i]) {
	// 		cout << "{" << x.first << "," << x.second << "} ";
	// 	}
	// 	cout << endl;
	// }

	double l = 0.5, r = 101, mid;

	while (r-l > EPS) {
		mid = (l+r) / 2;

		if (can(mid, g, n))
			l = mid;
		else
			r = mid;
	}

	cout << l;

	return 0;
}