    //For higher stack size use g++ -O2 -std=c++11 -Wall -Wl,--stack=268435456 a.cpp -o a.exe in cmd
    #include <bits/stdc++.h>
    #include <cstdio>
    #include <cstring>
    #include <cmath>
    #include <cstring>
    #include <chrono>
    #include <complex>
    #define ll long long
    #define ld long double
    #define vi vector<int>
    #define vll vector<ll>
    #define vvi vector < vi >
    #define pii pair<int,int>
    #define pll pair<long long, long long>
    #define mod 1000000007
    #define inf 1000000000000000001;
    #define all(c) c.begin(),c.end()
    #define mp(x,y) make_pair(x,y)
    #define mem(a,val) memset(a,val,sizeof(a))
    #define eb emplace_back
    #define pb push_back
    #define f first
    #define s second
    
    using namespace std;

    // Disjoint Set DataStructure
    int parent[151];         // reserve space for map if n > 10000
    int urank[151];
    int maxi[151],mini[151];

    void create(ll x, ll y)
    {
        parent[x] = x ;
        urank[x] = 1 ;         // rank = no. of nodes in its subtree
        maxi[x]=y;
        mini[x]=y;
    }

    ll find(ll x)
    {
        if( parent[x] != x )    //path compression
        {
            parent[x] = find(parent[x]) ;
        }
        return parent[x];
    }

    void merge(ll x, ll y)
    {
        ll xroot = find(x);
        ll yroot = find(y);
        if(xroot==yroot)
            return;

        if( urank[xroot] <= urank[yroot] )    // Union by rank
        {
            parent[xroot] = yroot ;
            urank[yroot] = urank[yroot] + urank[xroot] ;
            maxi[yroot] = max(maxi[yroot],maxi[xroot]);
            mini[yroot] = min(mini[yroot],mini[xroot]);
        }
        else
        {
            parent[yroot] = xroot;
            urank[xroot] = urank[xroot] + urank[yroot] ;
            maxi[xroot] = max(maxi[yroot],maxi[xroot]);
            mini[xroot] = min(mini[yroot],mini[xroot]);
        }
    }


    int n;
    pii ar[101];

    bool intersect(ll x1,ll y1,ll x2,ll y2,ld r)
    {
        if(4*r*r > (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2))
            return true;
        return false;
    }

    bool func(ld r)
    {
        int i,j,x;
        for(i=1;i<=n;++i)
        {
            create(i,ar[i].s);
        }
        for(i=1;i<=n;++i)
        {
            for(j=i+1;j<=n;++j)
            {
                if(intersect(ar[i].f,ar[i].s,ar[j].f,ar[j].s,r))
                {
                    // cout<<i<<"..."<<j<<" "<<r<<endl;
                    merge(i,j);
                }
            }
        }
        for(i=1;i<=n;++i)
        {
            x=find(i);
            if(maxi[x]+2*r > 100 && mini[x]-2*r < -100)
            {
                // cout<<i<<" "<<x<<" "<<r<<endl;
                return false;
            }
        }
        return true;
    }

    int main()
    {
        std::ios::sync_with_stdio(false);
        int T;
        T=1;
        // cin.ignore(); must be there when using getline(cin, s)
        while(T--)
        {
            int i,j;
            cin>>n;
            for(i=1;i<=n;++i)
            {
                cin>>ar[i].f>>ar[i].s;
            }
            ld l=0.0,r=200,mid,ans=0.0;;
            for(i=1;i<=100;++i)
            {
                mid=(l+r)/2;
                if(func(mid))
                {
                    ans=mid;
                    l=mid;
                }
                else
                {
                    r=mid;
                }
            }
            printf("%.9Lf\n",ans);
        }
        return 0;
    }

#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)n; i++)
using ll = long long;
const double eps = 1e-10;
const double INF = 1e9;

class Union_Find{
  vector<int> par; vector<int> rank; vector<int> num;
public:
  Union_Find(int n) {
    par = vector<int>(n); rank = vector<int>(n,0); num = vector<int>(n,1);
    rep(i,n) par[i] = i;
  }
  int find(int x) {
    if(par[x] == x) return x;
    else  return par[x] = find(par[x]);
  }
  int number(int x) {
    return num[find(x)];
  }
  void unite(int x, int y) {
    x = find(x); y = find(y);
    if (x == y) return;
    if (rank[x] < rank[y]) swap(x, y);
    if (rank[x] == rank[y]) rank[x]++;
    par[y] = x;
    num[x] += num[y];
  } 
  bool same(int x, int y) {
    return find(x) == find(y);
  }
};

int main(){
  int n;
  cin >> n;
  double x[n], y[n];
  rep(i,n) cin >> x[i] >> y[i];
  double l = 0, r = 100.0;
  while(r - l > eps) {
    double m = (l + r) / 2;
    Union_Find uf(n+2);
    rep(i,n) {
      if(y[i]+m > -m+100.0) uf.unite(n,i);
      if(y[i]-m < m-100.0) uf.unite(n+1,i);
    }
    rep(i,n) rep(j,n) if((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]) < 4.0*m*m) uf.unite(i,j);
    if(uf.find(n) == uf.find(n+1)) r = m;
    else l = m;
  }
  printf("%.12lf\n",l);
  return 0;
}
