#include <iostream>
#include <iomanip>
#include <vector>

class union_find {
	const int N; // the number of nodes
	int M; // the number of trees
	std::vector<int> parent, sz;
public :
	union_find(const int& n) : N(n), M(n), parent(n, -1), sz(n, 1) {}

	const int& root(const int& k) {return ((parent[k] == -1)?k:(parent[k] = root(parent[k])));}
	bool is_united(const int& i, const int& j) {return (root(i) == root(j));}
	const int& count_trees() const {return M;}
	const int& size(const int& k) {return sz[root(k)];}

	bool unite(int i, int j) {
		i = root(i); j = root(j);
		if (i == j) return false;
		if (sz[i] < sz[j]) std::swap(i, j);
		sz[i] += sz[j];
		parent[j] = i;
		M--;
		return true;
	}
};

int main() {
	int N;
	std::cin >> N;
	int x[N], y[N];
	for (int i = 0; i < N; i++) std::cin >> x[i] >> y[i];

	double ok = 0, ng = 101;
	while (ng - ok > 0.00001) {
		double mid = (ok + ng) / 2;
		union_find uf(N + 2);
		for (int i = 0; i < N - 1; i++) {
			for (int j = i + 1; j < N; j++) {
				if ((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) < 4 * mid * mid) uf.unite(i, j);
			}
		}
		for (int i = 0; i < N; i++) {
			if (100 - y[i] < mid * 2) uf.unite(i, N);
			if (y[i] + 100 < mid * 2) uf.unite(i, N + 1);
		}
		if (uf.is_united(N, N + 1)) ng = mid;
		else ok = mid;
	}

	std::cout << std::fixed << std::setprecision(5) << ok << '\n';
}
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll INF = 9223372036854775807;
const ll MOD = 1000000007;
const long double PI = acos(-1);
#define pb push_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define o0(a) cout<<a<<" "
#define o1(a) cout<<a<<"\n"
#define o2(a, b) cout<<a<<" "<<b<<"\n"
#define o3(a, b, c) cout<<a<<" "<<b<<" "<<c<<"\n"
#define o4(a, b, c, d) cout<<a<<" "<<b<<" "<<c<<" "<<d<<"\n"
#define i1(a) cin>>a
#define i2(a, b) cin>>a>>b
#define i3(a, b, c) cin>>a>>b>>c
#define i4(a, b, c, d) cin>>a>>b>>c>>d
#define fi first
#define se second

inline ll power(ll a, ll b, ll z = MOD)
{
	ll res = 1;
	a = (a%z);
	while(b)
	{
		if(b&1)
			res = (res*a)%z;
		a = (a*a)%z;
		b = b>>1;
	}
	return res;
}

inline ll inverse(ll a, ll z = MOD)
{
	return power(a, z-2, z);
}

ll extend(ll a, ll b, ll &x, ll &y)
{
	if(b == 0)
	{
		x = 1;
		y = 0;
		return a;
	}
	ll x1, y1;
	ll g = extend(b, a%b, x1, y1);
	x = y1;
	y = x1- (a/b)*y1;
	return g;
}

class matrix
{
	public:
	ll n, aray[5][5], z = MOD-1;
	matrix(ll n)
	{
		this->n = n;
		for(ll i=0;i<n;i++)
		{
			for(ll j=0;j<n;j++)
				aray[i][j] = (i == j);
		}
	}
	matrix operator+(const matrix& a)
	{
		matrix ans = matrix(n);
		for(ll i=0;i<n;i++)
		{
			for(ll j=0;j<n;j++)
				ans.aray[i][j] = (a.aray[i][j] + aray[i][j])%z;
		}
		return ans;
	}
	matrix operator*(const matrix& a)
	{
		matrix ans = matrix(n);
		for(ll i=0;i<n;i++)
		{
			for(ll j=0;j<n;j++)
			{
				ans.aray[i][j] = 0;
				for(ll k=0;k<n;k++)
					ans.aray[i][j] = (ans.aray[i][j] + aray[i][k]*a.aray[k][j])%z;
			}
		}
		return ans;
	}
};

inline matrix mat_power(matrix x, ll b, ll z = MOD)
{
	matrix ans = matrix(x.n);
	while(b)
	{
		if(b&1)
			ans = ans*x;
		x = x*x;
		b = b>>1;
	}
	return ans;
}

// void build(ll node, ll l, ll r)
// {
//     lazy[node] = 0;
//     if(l == r)
//     {
//         tree[node] = aray[l];
//         return ;
//     }
//     ll mid = (l+r)>>1;
//     build(node<<1, l, mid);
//     build((node<<1)+1, mid+1, r);
//     tree[node] = tree[node<<1] + tree[(node<<1)+1];
//     return ;
// }

// void update(ll node, ll l, ll r, ll left, ll right, ll val)
// {
//     if(lazy[node] != 0)
//     {
//         tree[node] += (r-l+1)*lazy[node];
//         if(l != r)
//         {
//             lazy[node<<1] += lazy[node];
//             lazy[(node<<1)+1] += lazy[node];
//         }
//         lazy[node] = 0;
//     }
//     if(left > r || l > right)
//         return ;
//     if(left <= l && right >= r)
//     {
//         tree[node] += val*(r-l+1);
//         if(l != r)
//         {
//             lazy[node<<1] += val;
//             lazy[(node<<1)+1] += val;
//         }
//         return ;
//     }
//     ll mid = (l+r)>>1;
//     update(node<<1, l, mid, left, right, val);
//     update((node<<1)+1, mid+1, r, left, right, val);
//     tree[node] = tree[node<<1] + tree[(node<<1)+1];
//     return ;
// }

// ll query(ll node, ll l, ll r, ll left, ll right)
// {
//     if(left > r || l > right)
//         return 0;
//     if(lazy[node] != 0)
//     {
//         tree[node] += (r-l+1)*lazy[node];
//         if(l != r)
//         {
//             lazy[node<<1] += lazy[node];
//             lazy[(node<<1)+1] += lazy[node];
//         }
//         lazy[node] = 0;
//     }
//     if(left <= l && right >= r)
//         return tree[node];
//     ll mid = (l+r)>>1;
//     return query(node<<1, l, mid, left, right) + query((node<<1)+1, mid+1, r, left, right);
// }

ll x;

map<ll, ll> m;

ll f(ll a)
{
    if(m.count(a))
        return m[a];
    if(a == 1)
        return m[a] = abs(a-x);
    if(a&1)
        return m[a] = min(abs(a-x), min(f((a-1)>>1), f((a+1)>>1)) + 2);
    return m[a] = min(abs(a-x), f(a>>1)+1);
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll y;
    cin>>x>>y;
    cout<<f(y)<<"\n";
    return 0;
}