#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bitset>
using namespace std;
const int lim=1000000000;
struct data{
	int x,y;
}a[3111];
struct edge{
	int t,next,v;
}g[11000001];
bitset<3111> w[3111],tmp;
int ans,i,j,k,n,m,tot,dis[3111][3111],h[3111];
void addedge(int x,int y){
	g[++tot].t=y;g[tot].next=h[x];h[x]=tot;
	g[++tot].t=x;g[tot].next=h[y];h[y]=tot;
	w[x][y]=w[y][x]=1;
}
bool check(int x){
	int i,j;
	memset(h,0,sizeof(h));tot=0;
	for (i=1;i<=n;i++) w[i].reset();
	for (i=1;i<n;i++)
	 for (j=i+1;j<=n;j++)
	  if (dis[i][j]>=x) addedge(i,j);
	for (i=1;i<=n;i++)
	 for (j=h[i];j;j=g[j].next){
		tmp=(w[i]&w[g[j].t]);
		if (tmp.any()) return 1;
	 }
	return 0;
}
int solve(){
	int l,r,m;
	for (l=0,r=lim;l<r-1;){
		m=(l+r)>>1;
		if (check(m)) l=m;else r=m-1;
	}
	return (check(r))?r:l;
}
int sqr(int x){
	return x*x;
}
int main(){
	scanf("%d",&n);
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++) dis[i][j]=dis[j][i]=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y);
	ans=solve();
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int lim=1000000000;
struct data{
	int x,y;
}a[3111];
struct edge{
	int t,next,v;
}g[11000001];
int ans,i,j,k,n,m,tot,dis[3111][3111],d[3111],h[3111],q[3111];
void addedge(int x,int y){
	g[++tot].t=y;g[tot].next=h[x];h[x]=tot;
	g[++tot].t=x;g[tot].next=h[y];h[y]=tot;
	d[x]++;d[y]++;
}
bool check(int x){
	int i,j,k,t1,t2;
	memset(h,0,sizeof(h));memset(d,0,sizeof(d));tot=0;
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++)
	  if (dis[i][j]>=x) addedge(i,j);
	for (i=1;i<=n;i++)
	 for (j=h[i];j;j=g[j].next){
	 	if (d[i]>d[g[j].t]) t1=i,t2=g[j].t;else t1=g[j].t,t2=i;
	 	for (k=h[t2];k;k=g[k].next)
		 if (g[k].t!=t1&&dis[t1][g[k].t]>=x) return 1;
	 }
	return 0;
}
int solve(){
	int l,r,m;
	for (l=0,r=lim;l<r-1;){
		m=(l+r)>>1;
		if (check(m)) l=m;else r=m-1;
	}
	return (check(r))?r:l;
}
int sqr(int x){
	return x*x;
}
int main(){
	scanf("%d",&n);
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++) dis[i][j]=dis[j][i]=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y);
	ans=solve();
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bitset>
using namespace std;
const int lim=1000000000;
struct data{
	int x,y;
}a[3011];
struct edge{
	int t,next,v;
}g[3011*3011/2+1];
bitset<3011> w[3011];
int ans,i,j,k,n,m,tot,dis[3011][3011],h[3011],q[3011*3011/2+1];
void addedge(int x,int y){
	g[++tot].t=y;g[tot].next=h[x];h[x]=tot;
	g[++tot].t=x;g[tot].next=h[y];h[y]=tot;
	w[x][y]=w[y][x]=1;
}
bool check(int x){
	int i,j;
	memset(h,0,sizeof(h));tot=0;
	for (i=1;i<=n;i++) w[i].reset();
	for (i=1;i<n;i++)
	 for (j=i+1;j<=n;j++)
	  if (dis[i][j]>=x) addedge(i,j);
	for (i=1;i<=n;i++)
	 for (j=h[i];j;j=g[j].next){
		if ((w[i]&w[g[j].t]).any()) return 1;
	 }
	return 0;
}
int solve(){
	int l,r,m;
	for (l=1,r=q[0];l<r-1;){
		m=(l+r)>>1;
		if (check(q[m])) l=m;else r=m-1;
	}
	return (check(q[r]))?q[r]:q[l];
}
int sqr(int x){
	return x*x;
}
int main(){
	scanf("%d",&n);q[0]=0;
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++) dis[i][j]=dis[j][i]=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y),q[++q[0]]=dis[i][j];
	sort(q+1,q+1+q[0]);
	ans=solve();
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bitset>
using namespace std;
const int lim=1000000000;
struct data{
	int x,y;
}a[3011];
bitset<3011> w[3011];
int ans,i,j,k,n,m,dis[3011][3011],q[3011*3011/2+1];
bool check(int x){
	int i,j;
	for (i=1;i<=n;i++) w[i].reset();
	for (i=1;i<n;i++)
	 for (j=i+1;j<=n;j++)
	  if (dis[i][j]>=x)
	   if ((w[i]&w[j]).any()) return 1;
	return 0;
}
int solve(){
	int l,r,m;
	for (l=1,r=q[0];l<r-1;){
		m=(l+r)>>1;
		if (check(q[m])) l=m;else r=m-1;
	}
	return (check(q[r]))?q[r]:q[l];
}
int sqr(int x){
	return x*x;
}
int main(){
	scanf("%d",&n);q[0]=0;
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++) dis[i][j]=dis[j][i]=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y),q[++q[0]]=dis[i][j];
	sort(q+1,q+1+q[0]);
	ans=solve();
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bitset>
using namespace std;
const int lim=1000000000;
struct data{
	int x,y;
}a[3011];
bitset<3011> w[3011];
int ans,i,j,k,n,m,dis[3011][3011],q[3011*3011/2+1];
bool check(int x){
	int i,j;
	for (i=1;i<=n;i++) w[i].reset();
	for (i=1;i<n;i++)
	 for (j=i+1;j<=n;j++)
	  if (dis[i][j]>=x) w[i][j]=w[j][i]=1;
	for (i=1;i<n;i++)
	 for (j=i+1;j<=n;j++)
	  if (dis[i][j]>=x)
	   if ((w[i]&w[j]).any()) return 1;
	return 0;
}
int solve(){
	int l,r,m;
	for (l=1,r=q[0];l<r-1;){
		m=(l+r)>>1;
		if (check(q[m])) l=m;else r=m-1;
	}
	return (check(q[r]))?q[r]:q[l];
}
int sqr(int x){
	return x*x;
}
int main(){
	scanf("%d",&n);q[0]=0;
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++) dis[i][j]=dis[j][i]=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y),q[++q[0]]=dis[i][j];
	sort(q+1,q+1+q[0]);
	ans=solve();
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int lim=1000000000;
struct data{
	int x,y;
}a[3111];
int ans,i,j,k,n,m,c[3111],dis[3111][3111];
bool dfs(int x,int v){
	int i;
	for (i=1;i<=n;i++){
		if (dis[x][i]<v) continue;
		if (c[i]){
			if (c[i]==c[x]) return 1;
		}else{
			c[i]=3-c[x];
			if (dfs(i,v)) return 1;
		}
	}
	return 0;
}
bool check(int x){
	int i;
	memset(c,0,sizeof(c));
	for (i=1;i<=n;i++)
	 if (!c[i]){
	 	c[i]=1;
	 	if (dfs(i,x)) return 1;
	 }
	return 0;
}
int solve(){
	int l,r,m;
	for (l=0,r=lim;l<r-1;){
		m=(l+r)>>1;
		if (check(m)) l=m;else r=m-1;
	}
	return (check(r))?r:l;
}
int sqr(int x){
	return x*x;
}
int main(){
	scanf("%d",&n);
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<=n;i++)
	 for (j=i;j<=n;j++) dis[i][j]=dis[j][i]=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y);
	ans=solve();
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<bitset>
using namespace std;
const int lim=1000000000;
struct pt{
	int x,y;
}a[3011];
struct data{
	int a,b,d;
}q[3011*3011/2+2];
bitset<3011> w[3011];
int ans,i,j,k,n,m,tot;
int sqr(int x){
	return x*x;
}
bool cmp(data a,data b){
	return a.d>b.d;
}
int main(){
	scanf("%d",&n);tot=0;
	for (i=1;i<=n;i++) scanf("%d%d",&a[i].x,&a[i].y);
	for (i=1;i<n;i++)
	 for (j=i+1;j<=n;j++) k=sqr(a[i].x-a[j].x)+sqr(a[i].y-a[j].y),q[++tot].a=i,q[tot].b=j,q[tot].d=k;
	sort(q+1,q+1+tot,cmp);
	for (i=1;i<=tot;i++){
		if ((w[q[i].a]&w[q[i].b]).any()){
			ans=q[i].d;break;
		}
		w[q[i].a][q[i].b]=w[q[i].b][q[i].a]=1;
	}
	printf("%.9lf\n",sqrt(ans)/2);
	return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
//par up[maxn];
int u;
//par down[maxn];
int d;
vector<par>hull;
vector<par>up;
vector<par>down;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

par vect(par a, par b) {
    return make_pair(b.first-a.first,b.second-a.second);
}

ll cross(par a, par b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a)
{
    if(a > 0)return 1;
    if(a < 0)return -1;
    return 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && sgn(cross(vect(up[u - 2],up[u - 1]),vect(up[u - 2],lista[i]))) != -1)
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && sgn(cross(vect(down[d - 2],down[d - 1]),vect(down[d - 2],lista[i]))) != -1)
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*   for(int i = 0; i < u; i++)
    hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
    hull.push_back(down[j]);
    */
    int k = 0;
    ll res = 0;
    for(int i = 0; i < up.size(); i++)
    {
        while(k != down.size() - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

void alternative()
{
    up.clear(); down.clear();
    for(int j = 0; j < lista.size(); j++)
    {
        if(up.size() < 2)
        {
            up.push_back(lista[j]);
            continue;
        }
        while(up.size() > 1 && sgn(cross(vect(up[up.size() - 2],up[up.size() - 1]),vect(up[up.size() - 2],lista[j])))  != -1)
        {
            up.pop_back();
        }
        up.push_back(lista[j]);
    }
    for(int j = lista.size()-1; j>=0; j--)
    {
        if(down.size()<2)
        {
            down.push_back(lista[j]);
            continue;
        }
        while(down.size() > 1 && sgn(cross(vect(down[down.size() - 2],down[down.size() - 1]),vect(down[down.size() - 2], lista[j]))) !=-1)
        {
            down.pop_back();
        }

        down.push_back(lista[j]);
    }

}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        bool t = false;
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            alternative();
            int kde=0;
            for(int i = 0; i < up.size(); i++)
            {
                while(kde != down.size() - 1 && dist(up[i], down[kde + 1]) > dist(up[i], down[kde]))
                {
                    kde++;
                }
                if(dist(up[i], down[kde]) >= middle)
                {
                    t = true;
                }
                if(t)
                    break;
            }

            if(t)
                break;
        }
        if(t)
            ini = middle;
        else
            fin = middle;

    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
 /*   for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);
*/
    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 1 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 1 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        bool t = false;
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            convexhull();
            int kde=0;
            for(int i = 0; i < u; i++)
            {
                while(kde != d - 1 && dist(up[i], down[kde + 1]) > dist(up[i], down[kde]))
                {
                    kde++;
                }
                if(dist(up[i], down[kde]) >= middle)
                {
                    t = true;
                }
                if(t)
                    break;
            }

            if(t)
                break;
        }
        if(t)
            ini = middle;
        else
            fin = middle;

    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 1 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 1 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    hull.clear();
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = 0;

    int size = hull.size();
    for(int i = 0; i < size; i++)
    {
        while(dist(hull[i],hull[(k + 1)%size]) > dist(hull[i],hull[k]))
            k = (k + 1)%size;
        res = max(res,dist(hull[i],hull[k]));
    }

    /*for(int i = 0; i < u; i++)
    {
    while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
    {
    k++;
    res = max(res,dist(up[i],down[k]));
    }
    }*/
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        bool t = false;
        for(int i = n - 1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                t = true;
                break;
            }
        }
        if(t)
            ini = middle;
        else
            fin = middle;
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 1 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 1 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        bool t = false;
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            convexhull();
            ll res = rotatingcalipers();
            /*int kde=0;
            for(int i = 0; i < u; i++)
            {
                while(kde != d - 1 && dist(up[i], down[kde + 1]) > dist(up[i], down[kde]))
                {
                    kde++;
                }
                if(dist(up[i], down[kde]) >= middle)
                {
                    t = true;
                }
                if(t)
                    break;
            }

            if(t)
                break;*/
            if(res >= middle)
            {
                t = true;
                break;
            }
        }
        if(t)
            ini = middle;
        else
            fin = middle;

    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
 /*   for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);
*/
    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini)/2.0);
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;
//vector<par>up;
//vector<par>down;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

par vect(par a, par b) {
    return make_pair(b.first-a.first,b.second-a.second);
}

ll cross(par a, par b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a)
{
    if(a > 0)return 1;
    if(a < 0)return -1;
    return 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

//ll rotatingcalipers()
//{
//  /*   for(int i = 0; i < u; i++)
//  hull.push_back(up[i]);
//  for(int j = 1; j < d - 1; j++)
//  hull.push_back(down[j]);
//  */
//  int k = 0;
//  ll res = 0;
//  for(int i = 0; i < up.size(); i++)
//  {
//      while(k != down.size() - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
//      {
//          k++;
//          res = max(res,dist(up[i],down[k]));
//      }
//  }
//  return res;
//}
//
//void alternative()
//{
//  up.clear(); down.clear();
//  for(int j = 0; j < lista.size(); j++)
//  {
//      if(up.size() < 2)
//      {
//          up.push_back(lista[j]);
//          continue;
//      }
//      while(up.size() > 1 && sgn(cross(vect(up[up.size() - 2],up[up.size() - 1]),vect(up[up.size() - 2],lista[j])))  != -1)
//      {
//          up.pop_back();
//      }
//      up.push_back(lista[j]);
//  }
//  for(int j = lista.size()-1; j>=0; j--)
//  {
//      if(down.size()<2)
//      {
//          down.push_back(lista[j]);
//          continue;
//      }
//      while(down.size() > 1 && sgn(cross(vect(down[down.size() - 2],down[down.size() - 1]),vect(down[down.size() - 2], lista[j]))) !=-1)
//      {
//          down.pop_back();
//      }
//
//      down.push_back(lista[j]);
//  }
//
//
//}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        bool t = false;
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            convexhull();
            int kde=0;
            for(int i = 0; i < u; i++)
            {
                while(kde != d - 1 && dist(up[i], down[kde + 1]) > dist(up[i], down[kde]))
                {
                    kde++;
                }
                if(dist(up[i], down[kde]) >= middle)
                {
                    t = true;
                }
                if(t)
                    break;
            }

            if(t)
                break;
        }
        if(t)
            ini = middle;
        else
            fin = middle;

    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
//par up[maxn];
int u;
//par down[maxn];
int d;
vector<par>hull;
vector<par>up;
vector<par>down;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

par vect(par a, par b) {
    return make_pair(b.first-a.first,b.second-a.second);
}

ll cross(par a, par b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a)
{
    if(a > 0)return 1;
    if(a < 0)return -1;
    return 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && sgn(cross(vect(up[u - 2],up[u - 1]),vect(up[u - 2],lista[i]))) != -1)
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && sgn(cross(vect(down[d - 2],down[d - 1]),vect(down[d - 2],lista[i]))) != -1)
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*   for(int i = 0; i < u; i++)
    hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
    hull.push_back(down[j]);
    */
    int k = 0;
    ll res = 0;
    for(int i = 0; i < up.size(); i++)
    {
        while(k != down.size() - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

void alternative()
{
    up.clear(); down.clear();
    for(int j = 0; j < lista.size(); j++)
    {
        if(up.size() < 2)
        {
            up.push_back(lista[j]);
            continue;
        }
        while(up.size() > 1 && sgn(cross(vect(up[up.size() - 2],up[up.size() - 1]),vect(up[up.size() - 2],lista[j])))  != -1)
        {
            up.pop_back();
        }
        up.push_back(lista[j]);
    }
    for(int j = lista.size()-1; j>=0; j--)
    {
        if(down.size()<2)
        {
            down.push_back(lista[j]);
            continue;
        }
        while(down.size() > 1 && sgn(cross(vect(down[down.size() - 2],down[down.size() - 1]),vect(down[down.size() - 2], lista[j]))) !=-1)
        {
            down.pop_back();
        }

        down.push_back(lista[j]);
    }

}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;

        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            alternative();
            //convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 1 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 1 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);*/

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n - 1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

par vect(par a, par b) {
    return make_pair(b.first-a.first,b.second-a.second);
}

ll cross(par a, par b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a)
{
    if(a > 0)return 1;
    if(a < 0)return -1;
    return 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && sgn(cross(vect(up[u - 2],up[u - 1]),vect(up[u - 2],lista[i]))) != -1)
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && sgn(cross(vect(down[d - 2],down[d - 1]),vect(down[d - 2],lista[i]))) != -1)
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*   for(int i = 0; i < u; i++)
    hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
    hull.push_back(down[j]);
    */
    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini)/2.0);
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return (ll)y.first*(ll)x.second - (ll)y.second*(ll)x.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res > middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return (ll)x.first*(ll)y.second - (ll)x.second*(ll)y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) >= dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u> 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = dist(up[0],down[0]);
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2.0;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res > middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt((double)ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 1 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 1 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        bool t = false;
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
                fin = middle;
        }
        /*if(t)
        ini = middle;
        else
        fin = middle;
        */

    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
//par up[maxn];
int u;
//par down[maxn];
int d;
vector<par>hull;
vector<par>up;
vector<par>down;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

par vect(par a, par b) {
    return make_pair(b.first-a.first,b.second-a.second);
}

ll cross(par a, par b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a)
{
    if(a > 0)return 1;
    if(a < 0)return -1;
    return 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && sgn(cross(vect(up[u - 2],up[u - 1]),vect(up[u - 2],lista[i]))) != -1)
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && sgn(cross(vect(down[d - 2],down[d - 1]),vect(down[d - 2],lista[i]))) != -1)
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*   for(int i = 0; i < u; i++)
    hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
    hull.push_back(down[j]);
    */
    int k = 0;
    ll res = 0;
    for(int i = 0; i < up.size(); i++)
    {
        while(k != down.size() - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

void alternative()
{
    up.clear(); down.clear();
    for(int j = 0; j < lista.size(); j++)
    {
        if(up.size() < 2)
        {
            up.push_back(lista[j]);
            continue;
        }
        int s = sgn(cross(vect(up[up.size() - 2],up[up.size() - 1]),vect(up[up.size() - 2],lista[j]))) ;

        while(up.size() > 1 && s != -1)
        {
            up.pop_back();
        }
        up.push_back(lista[j]);
    }
    for(int j = lista.size()-1; j>=0; j--)
    {
        if(down.size()<2)
        {
            down.push_back(lista[j]);
            continue;
        }
        int sign = sgn(cross(vect(down[down.size() - 2],down[down.size() - 1]),vect(down[down.size() - 2], lista[j])));
        while(down.size() > 1 && sign !=-1)
        {
            down.pop_back();
        }

        down.push_back(lista[j]);
    }

}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;

        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }

            alternative();
            //convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini)/2.0);
    return 0;
}


#include <cstdio>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <stack>
using namespace std;

#define For(i,n) for(int i=0; i<(n); i++)
#define mp(a,b) make_pair((a),(b))
typedef int ll;
typedef pair<int,int> pii;

int n;

ll vzd(pii a, pii b){
    return (ll)(a.first-b.first)*(a.first-b.first)+(ll)(a.second-b.second)*(a.second-b.second);
}

pii vect(pii a, pii b) {
    return mp(b.first-a.first,b.second-a.second);
}

ll cross(pii a, pii b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a) {
    if(a>0) return 1;
    if(a<0) return -1;
    return 0;
}

int main()
 {
    vector<pii> A;
    scanf("%d",&n);
    For(i,n)
    {
        int x,y;
        scanf(" %d %d",&x,&y);
        A.push_back(mp(x,y));
    }
    ll z = 0,k = 21000*21000;

    sort(A.begin(),A.end());

    vector<pii> B;
    vector<pii> up,down;
    while(k - z > 1)
    {
        ll stred=(z + k)/2;
        //if(k-z<0.000001) break;
        bool t=false;
        //pick first point
        for(int i=A.size()-1; i>=0; i--)
        {
            //pick distant points
            B.clear();
            For(j,n)
            {
                if(vzd(A[i],A[j])>=stred)
                {
                    B.push_back(A[j]);
                }
            }

            //convex hull
            up.clear(); down.clear();
            For(j,B.size())
            {
                if(up.size() < 2)
                {
                    up.push_back(B[j]);
                    continue;
                }
                int s = sgn(cross(vect(up[up.size() - 2],up[up.size() - 1]),vect(up[up.size() - 2],B[j]))) ;

                while(up.size() > 1 && s != -1)
                {
                    up.pop_back();
                }
                up.push_back(B[j]);
            }
            for(int j = B.size()-1; j>=0; j--)
            {
                if(down.size()<2)
                {
                    down.push_back(B[j]);
                    continue;
                }
                int sign = sgn(cross(vect(down[down.size() - 2],down[down.size() - 1]),vect(down[down.size() - 2], B[j])));
                while(down.size() > 1 && sign !=-1)
                {
                    down.pop_back();
                }

                down.push_back(B[j]);
            }

            ///////////////////////
            //find two distant points
            int kde=0;
            For(j,up.size())
            {
                while(kde != down.size() - 1 && vzd(up[j], down[kde + 1]) > vzd(up[j], down[kde]))
                {
                    kde++;
                }
                if(vzd(up[j], down[kde]) >= stred)
                {
                    t = true;
                }
                if(t)
                    break;
            }

            if(t)
                break;
        }
        if(t)
            z = stred;
        else
            k = stred;
    }
    printf("%0.9lf\n",sqrt(z/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res > middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt((double)ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u> 2 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);

    int k = 0;
    ll res = dist(up[0],down[0]);
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2.0;
        if(fin < 16)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt((double)ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par y;
    y.first = c.first - a.first;
    y.second = c.second - a.second;

    par x;
    x.first = b.first - a.first;
    x.second = b.second - a.second;
    return (ll)x.first*(ll)y.second - (ll)x.second*(ll)y.first < 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 1 && !turn(up[u - 2], up[u - 1], lista[i]))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 1 && !turn(down[d - 2], down[d - 1], lista[i]))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*for(int i = 0; i < u; i++)
        hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
        hull.push_back(down[j]);*/

    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k != d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini/4.0));
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <math.h>
#include <stdio.h>

using namespace std;
typedef pair<int,int>par;
typedef long double ld;
typedef long long ll;
#define maxn 3002

int n;
par p[maxn];
vector<par>lista;
par up[maxn];
int u;
par down[maxn];
int d;
vector<par>hull;

bool turn(par a, par b, par c)
{
    par x;
    x.first = c.first - a.first;
    x.second = c.second - a.second;
    par y;
    y.first = b.first - a.first;
    y.second = b.second - a.second;
    return x.first*y.second - x.second*y.first < 0;
}

par vect(par a, par b) {
    return make_pair(b.first-a.first,b.second-a.second);
}

ll cross(par a, par b) {
    return (ll)a.first*b.second-(ll)a.second*b.first;
}

int sgn(ll a)
{
    if(a > 0)return 1;
    if(a < 0)return -1;
    return 0;
}

void convexhull()
{
    int size = lista.size();

    for(int i = 0; i < size; i++)
    {
        while(u > 2 && sgn(cross(vect(up[u - 2],up[u - 1]),vect(up[u - 2],lista[i]))))
            u--;
        up[u++] = lista[i];
    }

    for(int i = size - 1; i >= 0; i--)
    {
        while(d > 2 && sgn(cross(vect(down[d - 2],down[d - 1]),vect(down[d - 2],lista[i]))))
            d--;
        down[d++] = lista[i];
    }
}

ll dist(par a, par b)
{
    return (ll)(b.first - a.first)*(b.first - a.first) + (ll)(b.second - a.second)*(b.second - a.second);
}

ll rotatingcalipers()
{
    /*   for(int i = 0; i < u; i++)
    hull.push_back(up[i]);
    for(int j = 1; j < d - 1; j++)
    hull.push_back(down[j]);
    */
    int k = 0;
    ll res = 0;
    for(int i = 0; i < u; i++)
    {
        while(k < d - 1 && dist(up[i],down[k + 1]) > dist(up[i],down[k]))
        {
            k++;
            res = max(res,dist(up[i],down[k]));
        }
    }
    return res;
}

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

    ll ini = 0;
    ll fin = 21000*21000;
    sort(p, p + n);

    while(fin - ini > 1)
    {
        ll middle = (ini + fin)/2;
        if(fin < 8)
        {
            int r = 9;
        }
        for(int i = n -1; i >= 0; i--)
        {
            lista.clear();
            u = d = 0;
            for(int j = 0; j < n; j++)//find the set S
            {
                if(dist(p[i],p[j]) >= middle)
                    lista.push_back(p[j]);
            }
            if(lista.size() >= 2)
            {
                int e= 0;
            }
            convexhull();
            ll res = rotatingcalipers();
            if(res >= middle)
            {
                ini = middle;
                break;
            }
            else
            {
                fin = middle;
            }

        }
    }

    printf("%.9lf\n",sqrt(ini)/2.0);
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    6111
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct Seg {
    int l, r;
    double lm;
} seg[N*4];
double len[N];
void buildtree(int l, int r, int now=1) {
    seg[now].l = l; seg[now].r = r;
    if (l == r) {
        seg[now].lm = len[r];
        return;
    }
    int mid = (l + r) / 2;
    buildtree(l, mid, now*2);
    buildtree(mid+1, r, now*2+1);
    seg[now].lm = max(seg[now*2].lm, seg[now*2+1].lm);
}
double query(int l, int r, int now=1) {
    if (l<=seg[now].l&&seg[now].r<=r)
        return seg[now].lm;
    int mid = (seg[now].l+seg[now].r)/2;
    double ans = 0.0;
    if (l<=mid)
        ans = max(ans, query(l, r, now*2));
    if (r > mid)
        ans = max(ans, query(l, r, now*2+1));
    return ans;
}

double getangle(double x, double y) {
    if (fabs(x) < eps) {
        if (y > 0)
            return pi / 2.0;
        else return 3.0*pi/2.0;
    }
    if (fabs(y) < eps) {
        if (x > 0)
            return 0.0;
        else return pi;
    }
    double s = fabs(y/(sqrt(x*x+y*y)));
    double ret = asin(s);
    if (x > eps && y > eps) return ret;
    if (x < -eps && y > eps) return pi - ret;
    if (x < -eps && y < -eps) return pi + ret;
    return 2.0*pi - ret;
}

double work(Point point[N], int n) {
    REP1(i, n) point[i].angle = getangle(point[i].x, point[i].y);
    sort(point+1, point+1+n);
    FOR1(i, n+1, n*2) {
        point[i] = point[i-n];
        point[i].angle += 2.0*pi;
    }
    REP1(i, n*2) len[i] = dis(Point(.0,.0), point[i]);
    int be = 1, en = 1;
    buildtree(1, n);
    double ans = 0.0;
    REP1(i, n) {
        double temp = len[i];
        while (point[en].angle - point[i].angle <= pi+eps)
            en++;
        while (point[be].angle - point[i].angle <= pi/3.0+eps)
            be++;
        int be1 = be, en1 = en;
        if (be > n && en > n)
            be -= n, en -= n;
        if (be<en && en <= n+1) {
            temp = min(temp, query(be, en-1));
            ans = max(ans, temp);
        }
        else if (be < en) {
            temp = min(temp, max(query(be, n), query(1, en-1-n)));
            ans = max(ans, temp);
        }
        be = be1, en = en1;
    }
    return ans / 2.0;
}
Point p1[N], p2[N];

int main()
{
    int n; cin >> n;
    REP(i, n) cin >> p1[i].x >> p1[i].y;
    double ans = 0.0;
    REP(i, n) {
        int cnt = 0;
        REP(j, n) {
            if (fabs(p1[i].x-p1[j].x) <= eps && fabs(p1[i].y-p1[j].y) <= eps)
                continue;
            p2[++cnt] = Point(p1[j].x-p1[i].x,p1[j].y-p1[i].y);
        }
        if (cnt >= 2)
            ans = max(ans, work(p2, cnt));
    }
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    6666
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct Seg {
    int l, r;
    double lm;
} seg[N*4];
double len[N];
void buildtree(int l, int r, int now=1) {
    seg[now].l = l; seg[now].r = r;
    if (l == r) {
        seg[now].lm = len[r];
        return;
    }
    int mid = (l + r) / 2;
    buildtree(l, mid, now*2);
    buildtree(mid+1, r, now*2+1);
    seg[now].lm = max(seg[now*2].lm, seg[now*2+1].lm);
}
double query(int l, int r, int now=1) {
    if (l<=seg[now].l&&seg[now].r<=r)
        return seg[now].lm;
    int mid = (seg[now].l+seg[now].r)/2;
    double ans = 0.0;
    if (l<=mid)
        ans = max(ans, query(l, r, now*2));
    if (r > mid)
        ans = max(ans, query(l, r, now*2+1));
    return ans;
}

double getangle(double x, double y) {
    if (fabs(x) < eps) {
        if (y > 0)
            return pi / 2.0;
        else return 3.0*pi/2.0;
    }
    if (fabs(y) < eps) {
        if (x > 0)
            return 0.0;
        else return pi;
    }
    double s = fabs(y/(sqrt(x*x+y*y)));
    double ret = asin(s);
    if (x > eps && y > eps) return ret;
    if (x < -eps && y > eps) return pi - ret;
    if (x < -eps && y < -eps) return pi + ret;
    return 2.0*pi - ret;
}

double work(Point point[N], int n) {
    REP1(i, n) point[i].angle = getangle(point[i].x, point[i].y);
    sort(point+1, point+1+n);
    FOR1(i, n+1, n*2) {
        point[i] = point[i-n];
        point[i].angle += 2.0*pi;
    }
    REP1(i, n*2) len[i] = dis(Point(.0,.0), point[i]);
    int be = 1, en = 1;
    buildtree(1, n*2);
    double ans = 0.0;
    REP1(i, n) {
        double temp = len[i];
        while (point[en].angle - point[i].angle <= pi+eps)
            en++;
        while (point[be].angle - point[i].angle <= pi/3.0+eps)
            be++;
        if (be<en) {
            temp = min(temp, query(be, en-1));
            ans = max(ans, temp);
        }
    }
    return ans / 2.0;
}
Point p1[N], p2[N];

int main()
{
    int n; scanf("%d", &n);
    REP(i, n) scanf("%lf%lf", &p1[i].x, &p1[i].y);
    double ans = 0.0;
    REP(i, n) {
        int cnt = 0;
        REP(j, n) {
            if (fabs(p1[i].x-p1[j].x) <= eps && fabs(p1[i].y-p1[j].y) <= eps)
                continue;
            p2[++cnt].x = p1[j].x-p1[i].x;
            p2[cnt].y = p1[j].y-p1[i].y;
        }
        if (cnt >= 2)
            ans = max(ans, work(p2, cnt));
    }
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    3111
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct  Edge{
    double len;
    int i, j;
    friend bool operator < (Edge a, Edge b) {
        return a.len < b.len;
    }
} edge[N*N];

Point p1[N*N];
bool flag[N];

int main()
{
    int n; scanf("%d", &n);
    REP(i, n) scanf("%lf%lf", &p1[i].x, &p1[i].y);
    double ans = 0.0;
    int ee = 0;
    REP(i, n) {
        REP(j, i) {
            edge[ee].i = i; edge[ee].j = j;
            edge[ee++].len = dis(p1[i], p1[j]);
        }
    }
    sort(edge, edge+ee);
    for (int i=ee-1; i>=0; i--) {
        if (flag[edge[i].i]&&flag[edge[i].j]) {
            ans = edge[i].len;
            break;
        }
        else
            flag[edge[i].i] = flag[edge[i].j] = true;
    }
    printf("%.10lf\n", ans/2.0);
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    6666
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct Seg {
    int l, r;
    double lm;
} seg[N*4];
double len[N];
void buildtree(int l, int r, int now=1) {
    seg[now].l = l; seg[now].r = r;
    if (l == r) {
        seg[now].lm = len[r];
        return;
    }
    int mid = (l + r) / 2;
    buildtree(l, mid, now*2);
    buildtree(mid+1, r, now*2+1);
    seg[now].lm = max(seg[now*2].lm, seg[now*2+1].lm);
}
double query(int l, int r, int now=1) {
    if (l<=seg[now].l&&seg[now].r<=r)
        return seg[now].lm;
    int mid = (seg[now].l+seg[now].r)/2;
    double ans = 0.0;
    if (l<=mid)
        ans = max(ans, query(l, r, now*2));
    if (r > mid)
        ans = max(ans, query(l, r, now*2+1));
    return ans;
}

double getangle(double x, double y) {
    if (fabs(x) < eps) {
        if (y > 0)
            return pi / 2.0;
        else return 3.0*pi/2.0;
    }
    if (fabs(y) < eps) {
        if (x > 0)
            return 0.0;
        else return pi;
    }
    double s = fabs(y/(sqrt(x*x+y*y)));
    double ret = asin(s);
    if (x > eps && y > eps) return ret;
    if (x < -eps && y > eps) return pi - ret;
    if (x < -eps && y < -eps) return pi + ret;
    return 2.0*pi - ret;
}

double work(Point point[N], int n) {
    REP1(i, n) point[i].angle = getangle(point[i].x, point[i].y);
    sort(point+1, point+1+n);
    FOR1(i, n+1, n*2) {
        point[i] = point[i-n];
        point[i].angle += 2.0*pi;
    }
    REP1(i, n*2) len[i] = dis(Point(.0,.0), point[i]);
    int be = 1, en = 1;
    buildtree(1, n*2);
    double ans = 0.0;
    REP1(i, n) {
        double temp = len[i];
        while (point[en].angle - point[i].angle <= pi+eps)
            en++;
        while (point[be].angle - point[i].angle <= pi/3.0+eps)
            be++;
        if (be<en) {
            temp = min(temp, query(be, en-1));
            ans = max(ans, temp);
        }
    }
    return ans / 2.0;
}
Point p1[N], p2[N];

int main()
{
    int n; cin >> n;
    REP(i, n) cin >> p1[i].x >> p1[i].y;
    double ans = 0.0;
    REP(i, n) {
        int cnt = 0;
        REP(j, n) {
            if (fabs(p1[i].x-p1[j].x) <= eps && fabs(p1[i].y-p1[j].y) <= eps)
                continue;
            p2[++cnt] = Point(p1[j].x-p1[i].x,p1[j].y-p1[i].y);
        }
        if (cnt >= 2)
            ans = max(ans, work(p2, cnt));
    }
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    6111
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct Seg {
    int l, r;
    double lm;
} seg[N*4];
double len[N];
void buildtree(int l, int r, int now=1) {
    seg[now].l = l; seg[now].r = r;
    if (l == r) {
        seg[now].lm = len[r];
        return;
    }
    int mid = (l + r) / 2;
    buildtree(l, mid, now*2);
    buildtree(mid+1, r, now*2+1);
    seg[now].lm = max(seg[now*2].lm, seg[now*2+1].lm);
}
double query(int l, int r, int now=1) {
    if (l<=seg[now].l&&seg[now].r<=r)
        return seg[now].lm;
    int mid = (seg[now].l+seg[now].r)/2;
    double ans = 0.0;
    if (l<=mid)
        ans = max(ans, query(l, r, now*2));
    if (r > mid)
        ans = max(ans, query(l, r, now*2+1));
    return ans;
}

double getangle(double x, double y) {
    if (fabs(x) < eps) {
        if (y > 0)
            return pi / 2.0;
        else return 3.0*pi/2.0;
    }
    if (fabs(y) < eps) {
        if (x > 0)
            return 0.0;
        else return pi;
    }
    double s = fabs(y/(sqrt(x*x+y*y)));
    double ret = asin(s);
    if (x > eps && y > eps) return ret;
    if (x < -eps && y > eps) return pi - ret;
    if (x < -eps && y < -eps) return pi + ret;
    return 2.0*pi - ret;
}

double work(Point point[N], int n) {
    REP1(i, n) point[i].angle = getangle(point[i].x, point[i].y);
    sort(point+1, point+1+n);
    FOR1(i, n+1, n*2) {
        point[i] = point[i-n];
        point[i].angle += 2.0*pi;
    }
    REP1(i, n*2) len[i] = dis(Point(.0,.0), point[i]);
    int be = 1, en = 1;
    buildtree(1, n);
    double ans = 0.0;
    REP1(i, n) {
        double temp = len[i];
        while (point[en].angle - point[i].angle <= pi+eps)
            en++;
        while (point[be].angle - point[i].angle <= pi/3.0+eps)
            be++;
        int be1 = be, en1 = en;
        if (be > n && en > n)
            be -= n, en -= n;
        if (be<en && en <= n+1) {
            temp = min(temp, query(be, en-1));
            ans = max(ans, temp);
        }
        else if (be < en) {
            temp = min(temp, max(query(be, n), query(1, en-1-n)));
        }
        be = be1, en = en1;
    }
    return ans / 2.0;
}
Point p1[N], p2[N];

int main()
{
    int n; cin >> n;
    REP(i, n) cin >> p1[i].x >> p1[i].y;
    double ans = 0.0;
    REP(i, n) {
        int cnt = 0;
        REP(j, n) {
            if (fabs(p1[i].x-p1[j].x) <= eps && fabs(p1[i].y-p1[j].y) <= eps)
                continue;
            p2[++cnt] = Point(p1[j].x-p1[i].x,p1[j].y-p1[i].y);
        }
        if (cnt >= 2)
            ans = max(ans, work(p2, cnt));
    }
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    3001
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct  Edge{
    double len;
    int i, j;
    friend bool operator < (Edge a, Edge b) {
        return a.len < b.len;
    }
} edge[N*N/2];

Point p1[N];
bool flag[N];

int main()
{
    int n; scanf("%d", &n);
    REP(i, n) scanf("%lf%lf", &p1[i].x, &p1[i].y);
    double ans = 0.0;
    int ee = 0;
    REP(i, n) {
        REP(j, i) {
            edge[ee].i = i; edge[ee].j = j;
            edge[ee++].len = dis(p1[i], p1[j]);
        }
    }
    sort(edge, edge+ee);
    for (int i=ee-1; i>=0; i--) {
        if (flag[edge[i].i]&&flag[edge[i].j]) {
            ans = edge[i].len;
            break;
        }
        else
            flag[edge[i].i] = flag[edge[i].j] = true;
    }
    printf("%.10lf\n", ans/2.0);
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    6111
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct Seg {
    int l, r;
    double lm;
} seg[N*4];
double len[N];
void buildtree(int l, int r, int now=1) {
    seg[now].l = l; seg[now].r = r;
    if (l == r) {
        seg[now].lm = len[r];
        return;
    }
    int mid = (l + r) / 2;
    buildtree(l, mid, now*2);
    buildtree(mid+1, r, now*2+1);
    seg[now].lm = max(seg[now*2].lm, seg[now*2+1].lm);
}
double query(int l, int r, int now=1) {
    if (l<=seg[now].l&&seg[now].r<=r)
        return seg[now].lm;
    int mid = (seg[now].l+seg[now].r)/2;
    double ans = 0.0;
    if (l<=mid)
        ans = max(ans, query(l, r, now*2));
    if (r > mid)
        ans = max(ans, query(l, r, now*2+1));
    return ans;
}

double getangle(double x, double y) {
    if (fabs(x) < eps) {
        if (y > 0)
            return pi / 2.0;
        else return 3.0*pi/2.0;
    }
    if (fabs(y) < eps) {
        if (x > 0)
            return 0.0;
        else return pi;
    }
    double s = fabs(y/(sqrt(x*x+y*y)));
    double ret = asin(s);
    if (x > eps && y > eps) return ret;
    if (x < -eps && y > eps) return pi - ret;
    if (x < -eps && y < -eps) return pi + ret;
    return 2.0*pi - ret;
}

double work(Point point[N], int n) {
    REP1(i, n) point[i].angle = getangle(point[i].x, point[i].y);
    sort(point+1, point+1+n);
    FOR1(i, n+1, n*2) {
        point[i] = point[i-n];
        point[i].angle += 2.0*pi;
    }
    REP1(i, n*2) len[i] = dis(Point(.0,.0), point[i]);
    int be = 1, en = 1;
    buildtree(1, n);
    double ans = 0.0;
    REP1(i, n) {
        double temp = len[i];
        while (point[en].angle - point[i].angle <= pi+eps)
            en++;
        while (point[be].angle - point[i].angle <= pi/3.0+eps)
            be++;
        if (be<en && en <= n+1) {
            temp = min(temp, query(be, en-1));
            ans = max(ans, temp);
        }
        else if (be < en) {
            temp = min(temp, max(query(be, n), query(1, en-1-n)));
        }
    }
    return ans / 2.0;
}
Point p1[N], p2[N];

int main()
{
    int n; cin >> n;
    REP(i, n) cin >> p1[i].x >> p1[i].y;
    double ans = 0.0;
    REP(i, n) {
        int cnt = 0;
        REP(j, n) {
            if (fabs(p1[i].x-p1[j].x) <= eps && fabs(p1[i].y-p1[j].y) <= eps)
                continue;
            p2[++cnt] = Point(p1[j].x-p1[i].x,p1[j].y-p1[i].y);
        }
        if (cnt >= 2)
            ans = max(ans, work(p2, cnt));
    }
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    3001
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct  Edge{
    double len;
    int i, j;
    friend bool operator < (Edge a, Edge b) {
        return a.len < b.len;
    }
} edge[N*N/2];

Point p1[N];
bool flag[N];

int main()
{
    int n; scanf("%d", &n);
    REP(i, n) scanf("%lf%lf", &p1[i].x, &p1[i].y);
    double ans = 0.0;
    int ee = 0;
    REP(i, n) {
        REP(j, i) {
            edge[ee].i = i; edge[ee].j = j;
            edge[ee++].len = dis(p1[i], p1[j]);
        }
    }
    sort(edge, edge+ee);
    for (int i=ee-1; i>=0; i--) {
        if (flag[edge[i].i]&&flag[edge[i].j]) {
            ans = edge[i].len;
            break;
        }
        else
            flag[edge[i].i] = flag[edge[i].j] = true;
    }
    printf("%.10lf\n", ans/2.0);
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    6111
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<n; i++)
#define  REP1(i,n)   for (int i=1; i<=n; i++)
#define  FOR(i,l,r)    for (int i=l; i<r; i++)
#define  FOR1(i,l,r) for (int i=l; i<=r; i++)
#define  TXT

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

using namespace std;

struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

struct Point {
    double x, y, angle;
    Point(double xx=0,double yy=0) {x=xx;y=yy;}
    friend bool operator < (Point a, Point b) {return a.angle<b.angle;}
    friend double dis(Point a, Point b) {return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));}
};

struct Seg {
    int l, r;
    double lm;
} seg[N*4];
double len[N];
void buildtree(int l, int r, int now=1) {
    seg[now].l = l; seg[now].r = r;
    if (l == r) {
        seg[now].lm = len[r];
        return;
    }
    int mid = (l + r) / 2;
    buildtree(l, mid, now*2);
    buildtree(mid+1, r, now*2+1);
    seg[now].lm = max(seg[now*2].lm, seg[now*2+1].lm);
}
double query(int l, int r, int now=1) {
    if (l<=seg[now].l&&seg[now].r<=r)
        return seg[now].lm;
    int mid = (seg[now].l+seg[now].r)/2;
    double ans = 0.0;
    if (l<=mid)
        ans = max(ans, query(l, r, now*2));
    if (r > mid)
        ans = max(ans, query(l, r, now*2+1));
    return ans;
}

double getangle(double x, double y) {
    if (fabs(x) < eps) {
        if (y > 0)
            return pi / 2.0;
        else return 3.0*pi/2.0;
    }
    if (fabs(y) < eps) {
        if (x > 0)
            return 0.0;
        else return pi;
    }
    double s = fabs(y/(sqrt(x*x+y*y)));
    double ret = asin(s);
    if (x > eps && y > eps) return ret;
    if (x < -eps && y > eps) return pi - ret;
    if (x < -eps && y < -eps) return pi + ret;
    return 2.0*pi - ret;
}

double work(Point point[N], int n) {
    REP1(i, n) point[i].angle = getangle(point[i].x, point[i].y);
    sort(point+1, point+1+n);
    FOR1(i, n+1, n*2) {
        point[i] = point[i-n];
        point[i].angle += 2.0*pi;
    }
    REP1(i, n*2) len[i] = dis(Point(.0,.0), point[i]);
    int be = 1, en = 1;
    buildtree(1, n);
    double ans = 0.0;
    REP1(i, n) {
        double temp = len[i];
        while (point[en].angle - point[i].angle <= pi+eps)
            en++;
        while (point[be].angle - point[i].angle <= pi/3.0+eps)
            be++;
        if (be<en && en <= n+1) {
            temp = min(temp, query(be, en-1));
            ans = max(ans, temp);
        }
        else if (be < en) {
            temp = min(temp, max(query(be, n), query(1, en-1-n)));
        }
    }
    return ans / 2.0;
}
Point p1[N], p2[N];

int main()
{
    int n; cin >> n;
    REP(i, n) cin >> p1[i].x >> p1[i].y;
    double ans = 0.0;
    REP(i, n) {
        int cnt = 0;
        REP(j, n) {
            if (fabs(p1[i].x-p1[j].x) <= eps && fabs(p1[i].y-p1[j].y) <= eps)
                continue;
            p2[++cnt] = Point(p1[j].x-p1[i].x,p1[j].y-p1[i].y);
        }
        if (cnt >= 2)
            ans = max(ans, work(p2, cnt));
    }
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}


//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <map>
#include <cassert>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <queue>
#include <complex>
#include <stack>
#include <string>
#include <bitset>
#include <iomanip>
#include <set>
#include <ctime>
#include <fstream>
#include <list>
#define  inf  0XFFFFFFFFFFFFFFFll
#define  dinf 1e11
#define  N    422222
#define  M    44444
#define  mod  1000000007ll
#define  LL   long long
#define  ULL  unsigned long long
#define  us   unsigned short int
#define  eps  1e-12
#define  pi   acos(-1.0)
#define  REP(i,n)    for (int i=0; i<(n); i++)
#define  REP1(i,n)   for (int i=1; i<=(n); i++)
#define  FOR(i,l,r)  for (int i=(l); i<(r); i++)
#define  FOR1(i,l,r) for (int i=(l); i<=(r); i++)
struct Complex{double x, y;Complex(double _x=0.0,double _y=0.0):x(_x),y(_y){}};
Complex operator + (Complex a,Complex b){return Complex(a.x+b.x,a.y+b.y);}
Complex operator - (Complex a,Complex b){return Complex(a.x-b.x,a.y-b.y);}
Complex operator * (Complex a,Complex b){return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);}

#define  TXT1

using namespace std;

#ifdef TXT
ifstream fi("in.txt");
#define  cin  fi
#endif

bitset<3001> bit[3001];

struct Edge {
    int i, j;
    LL l;
} edge[4500000];
LL x[3001], y[3001];
bool operator < (Edge a, Edge b) {
    return a.l > b.l;
}
int main()
{
    int n; cin >> n;
    REP(i, n) cin >> x[i] >> y[i];
    int ee = 0;
    REP(i, n) REP (j, i) {
        edge[ee].i = i;
        edge[ee].j = j;
        edge[ee++].l = (x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
    }
    sort(edge, edge+ee);
    double ans = 0;
    REP(i, ee) {
        if ((bit[edge[i].i]&bit[edge[i].j])!=0) {
            ans = edge[i].l;
            break;
        }
        bit[edge[i].i][edge[i].j] = bit[edge[i].j][edge[i].i] = 1;
    }
    cout << fixed << setprecision(10) << sqrt(ans)/2.0 << endl;
    return 0;
}