#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <bitset>
using namespace std;

int n,i,j,k,loop;
int x[3005],y[3005];
double dist[3005][3005],l,r,mid;
bitset<3005> f[3005],g;

double sqr(double x){return x*x;}

int main()
{
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d%d",&x[i],&y[i]);
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(i==j)dist[i][j]=-100000;
	else dist[i][j]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
	g.reset();
	l=0;r=50000;
	for(loop=50;loop;--loop)
	{
		mid=(l+r)/2;
		for(i=1;i<=n;++i)
		for(j=1;j<=n;++j)
		if(dist[i][j]>=mid)
		f[i][j]=1;else f[i][j]=0;
		for(i=1;i<=n;++i)
		{
			for(j=1;j<=n;++j)
			if(f[i][j])
			if((f[i]&f[j])!=g)
			break;
			if(j<=n)break;
		}
		if(i<=n)l=mid;
		else r=mid;
	}
	printf("%.20lf\n",mid/2);
}


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;

int n,i,j,k,loop,q,w,e;
int x[3005],y[3005],d[3005],id[3005];
double dist[3005][3005],l,r,mid,tmp;
bitset<3005> f[3005],g;

double sqr(double x){return x*x;}
inline bool cmp(const int &a,const int &b){return d[a]>d[b];}

int main()
{
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d%d",&x[i],&y[i]);
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(i==j)dist[i][j]=-100000;
	else dist[i][j]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
	for(loop=10000;loop;--loop)
	{
		q=rand()%n+1;
		for(w=rand()%n+1;w==q;w=rand()%n+1);
		for(e=rand()%n+1;e==q||e==w;e=rand()%n+1);
		tmp=min(dist[q][w],min(dist[q][e],dist[w][e]));
	}
	g.reset();
	for(i=1;i<=n;++i)id[i]=i;
	l=tmp;
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(dist[i][j]>r)r=dist[i][j];
	for(;r-l>1e-6;)
	{
		mid=(l+r)/2;
		for(i=1;i<=n;++i)d[i]=0;
		for(i=1;i<=n;++i)
		for(j=1;j<=n;++j)
		if(dist[i][j]>=mid)
		{
			f[i][j]=1;
			++d[i];
		}else f[i][j]=0;
		sort(id+1,id+n+1,cmp);
		for(i=1;i<=n;++i)
		{
			for(j=1;j<=n;++j)
			if(f[id[i]][id[j]])
			if((f[id[i]]&f[id[j]])!=g)
			break;
			if(j<=n)break;
		}
		if(i<=n)l=mid;
		else r=mid;
	}
	printf("%.20lf\n",mid/2);
}


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;

int n,i,j,k,loop;
int x[3005],y[3005],d[3005],id[3005];
double dist[3005][3005],l,r,mid;
bitset<3005> f[3005],g;

double sqr(double x){return x*x;}
inline bool cmp(const int &a,const int &b){return d[a]>d[b];}

int main()
{
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d%d",&x[i],&y[i]);
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(i==j)dist[i][j]=-100000;
	else dist[i][j]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
	g.reset();
	for(i=1;i<=n;++i)id[i]=i;
	l=0;r=50000;
	for(loop=35;loop;--loop)
	{
		mid=(l+r)/2;
		for(i=1;i<=n;++i)d[i]=0;
		for(i=1;i<=n;++i)
		for(j=1;j<=n;++j)
		if(dist[i][j]>=mid)
		{
			f[i][j]=1;
			++d[i];
		}else f[i][j]=0;
		sort(id+1,id+n+1,cmp);
		for(i=1;i<=n;++i)
		{
			for(j=1;j<=n;++j)
			if(f[id[i]][id[j]])
			if((f[id[i]]&f[id[j]])!=g)
			break;
			if(j<=n)break;
		}
		if(i<=n)l=mid;
		else r=mid;
	}
	printf("%.20lf\n",mid/2);
}


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;

int n,i,j,k,tot;
int x[3005],y[3005];
double dist[3005][3005];
bitset<3005> f[3005];

struct node
{
	int u,v;
	double c;
}t[5000005];

double sqr(double x){return x*x;}
inline bool cmp(const node &a,const node &b){return a.c>b.c;}

int main()
{
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d%d",&x[i],&y[i]);
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(i==j)dist[i][j]=-100000;
	else dist[i][j]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
	for(i=1;i<=n;++i)
	for(j=i+1;j<=n;++j)
	{
		++tot;
		t[tot].u=i;
		t[tot].v=j;
		t[tot].c=dist[i][j];
	}
	sort(t+1,t+tot+1,cmp);
	for(i=1;i<=tot;++i)
	{
		j=t[i].u;k=t[i].v;
		if((f[j]&f[k]).any())
		{
			printf("%.20lf\n",t[i].c/2);
			return 0;
		}
		f[j][k]=1;f[k][j]=1;
	}
}


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;

int n,i,j,k,loop;
int x[3005],y[3005],d[3005],id[3005];
double dist[3005][3005],l,r,mid;
bitset<3005> f[3005],g;

double sqr(double x){return x*x;}
inline bool cmp(const int &a,const int &b){return d[a]>d[b];}

int main()
{
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d%d",&x[i],&y[i]);
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(i==j)dist[i][j]=-100000;
	else dist[i][j]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
	g.reset();
	for(i=1;i<=n;++i)id[i]=i;
	l=0;r=50000;
	for(loop=50;loop;--loop)
	{
		mid=(l+r)/2;
		for(i=1;i<=n;++i)d[i]=0;
		for(i=1;i<=n;++i)
		for(j=1;j<=n;++j)
		if(dist[i][j]>=mid)
		{
			f[i][j]=1;
			++d[i];
		}else f[i][j]=0;
		sort(id+1,id+n+1,cmp);
		for(i=1;i<=n;++i)
		{
			for(j=1;j<=n;++j)
			if(f[id[i]][id[j]])
			if((f[id[i]]&f[id[j]])!=g)
			break;
			if(j<=n)break;
		}
		if(i<=n)l=mid;
		else r=mid;
	}
	printf("%.20lf\n",mid/2);
}


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <bitset>
#include <algorithm>
using namespace std;

int n,i,j,k,loop,q,w,e;
int x[3005],y[3005],d[3005],id[3005];
double dist[3005][3005],l,r,mid,tmp;
bitset<3005> f[3005],g;

double sqr(double x){return x*x;}
inline bool cmp(const int &a,const int &b){return d[a]>d[b];}

int main()
{
	scanf("%d",&n);
	for(i=1;i<=n;++i)scanf("%d%d",&x[i],&y[i]);
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(i==j)dist[i][j]=-100000;
	else dist[i][j]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]));
	for(loop=10000;loop;--loop)
	{
		q=rand()%n+1;
		for(w=rand()%n+1;w==q;w=rand()%n+1);
		for(e=rand()%n+1;e==q||e==w;e=rand()%n+1);
		tmp=min(dist[q][w],min(dist[q][e],dist[w][e]));
		if(tmp>l)l=tmp;
	}
	g.reset();
	for(i=1;i<=n;++i)id[i]=i;
	for(i=1;i<=n;++i)
	for(j=1;j<=n;++j)
	if(dist[i][j]>r)r=dist[i][j];
	for(;r-l>1e-6;)
	{
		mid=(l+r)/2;
		for(i=1;i<=n;++i)d[i]=0;
		for(i=1;i<=n;++i)
		for(j=1;j<=n;++j)
		if(dist[i][j]>=mid)
		{
			f[i][j]=1;
			++d[i];
		}else f[i][j]=0;
		sort(id+1,id+n+1,cmp);
		for(i=1;i<=n;++i)
		{
			for(j=1;j<=n;++j)
			if(f[id[i]][id[j]])
			if((f[id[i]]&f[id[j]])!=g)
			break;
			if(j<=n)break;
		}
		if(i<=n)l=mid;
		else r=mid;
	}
	printf("%.20lf\n",mid/2);
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

bitset<MAXN> ss[MAXN];
bitset<MAXN> buf;

bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i][j] = true;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                buf.reset();
                buf = ss[i];
                buf &= ss[j];
                if (buf.count() >= 1) return true;
            }
    return false;
}

int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    int l = 0, r = mx + 1;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(m)) l = m;
        else r = m;
    }
    cout << sqrtl(l)/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

bitset<MAXN> ss[MAXN];
bitset<MAXN> buf;

bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i][j] = true;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                buf.reset();
                buf = ss[i];
                buf &= ss[j];
                if (buf.count() >= 1) return true;
            }
    return false;
}
int ddst[MAXN*MAXN];
int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            ddst[i*n+j] = dist[i][j];
    sort(ddst, ddst + n * n);
    int l = 0, r = n * n + 1;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(ddst[m])) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(ddst[l])/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            dist[i][j] = fdist(i, j);
    int res = 0;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++) {
            int cc = 0;
            for (int t = 0; t < n; t++)
                if (t != i && t != j)
                    cc = max(cc, min(dist[i][t], dist[t][j]));
            res = max(res, min(cc, dist[i][j]));
        }
    cout.precision(1000);
    cout << sqrtl(res)/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            dist[i][j] = fdist(i, j);
    int res = 0, cc, * ptr1, * ptr2;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++) {
            cc = 0;
            ptr1 = dist[i] + j + 1;
            ptr2 = dist[j] + j + 1;
            for (int t = j + 1; t < n; t++, ptr1++, ptr2++)
                 cc = max(cc, min(*ptr1, *ptr2));
            res = max(res, min(cc, dist[i][j]));
        }
    cout.precision(1000);
    cout << sqrtl(res)/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

inline int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

struct btset{
    long long pool[47];
    inline void reset() {
        memset(pool, 0, sizeof pool);
    }
    inline void set(int x) {
        pool[x >> 8] |= 1LL << (x & ((1 << 8)-1));
    }
};

inline bool org1(btset & a, btset & b) {
    for (int i = 0; i < 47; i++) {
        if ((a.pool[i] & b.pool[i]) != 0) return true;
    }
    return false;
}

btset ss[MAXN];

inline bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i].set(j);
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                if (org1(ss[i], ss[j])) return true;
            }
    return false;
}
int ddst[MAXN*MAXN];
int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            ddst[i*n+j] = dist[i][j];
    sort(ddst, ddst + n * n);
    int l = 0, r = unique(ddst, ddst + n * n) - ddst;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(ddst[m])) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(ddst[l])/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

inline int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

struct btset{
    unsigned long long pool[47];
    inline void reset() {
        memset(pool, 0, sizeof pool);
    }
    inline void set(int x) {
        pool[x >> 8] |= ((unsigned long long)1) << (x & ((1 << 8)-1));
    }
};

inline bool org1(btset & a, btset & b) {
    for (int i = 0; i < 47; i++) {
        if ((a.pool[i] & b.pool[i]) != 0) return true;
    }
    return false;
}

btset ss[MAXN];

inline bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i].set(j);
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                if (org1(ss[i], ss[j])) return true;
            }
    return false;
}
int ddst[MAXN*MAXN];
int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            ddst[i*n+j] = dist[i][j];
    sort(ddst, ddst + n * n);
    int l = 0, r = n*n+1;//unique(ddst, ddst + n * n) - ddst;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(ddst[m])) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(ddst[l])/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

inline int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

struct btset{
    long long pool[47];
    inline void reset() {
        memset(pool, 0, sizeof pool);
    }
    inline void set(int x) {
        pool[x >> 8] |= 1LL << (x & ((1 << 8)-1));
    }
};

inline bool org1(btset & a, btset & b) {
    for (int i = 0; i < 47; i++) {
        if ((a.pool[i] & b.pool[i]) != 0) return true;
    }
    return false;
}

btset ss[MAXN];

inline bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i].set(j);
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                if (org1(ss[i], ss[j])) return true;
            }
    return false;
}
int ddst[MAXN*MAXN];
int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            ddst[i*n+j] = dist[i][j];
    sort(ddst, ddst + n * n);
    int l = 0, r = n*n+1;//unique(ddst, ddst + n * n) - ddst;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(ddst[m])) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(ddst[l])/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

bitset<MAXN> ss[MAXN];
bitset<MAXN> buf;

bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] > v)
                ss[i][j] = true;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++) {
            buf.reset();
            buf = ss[i];
            buf &= ss[j];
            if (buf.count() >= 2) return true;
        }
    return false;
}

int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    int l = 0, r = mx + 1;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(m)) l = m;
        else r = m;
    }
    cout << sqrtl(l)/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

inline int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

inline int count(long long x) {
    int res = 0;
    for (int i = 1LL; i != 0; i *= 2)
        res += (x&i) != 0;
    return res;
}

struct btset{
    long long pool[47];
    inline void reset() {
        memset(pool, 0, sizeof pool);
    }
    inline void set(int x) {
        pool[x >> 8] |= 1 << (x & ((1 << 8)-1));
    }
};

inline bool org1(btset & a, btset & b, int x) {
    int cnt = 0;
    for (int i = x >> 8; i < 47 && cnt < 2; i++) {
        if ((a.pool[i] & b.pool[i]) != 0) return true;
    }
    return false;
}

btset ss[MAXN];

inline bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i].set(j);
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                if (org1(ss[i], ss[j], j + 1)) return true;
            }
    return false;
}
int ddst[MAXN*MAXN];
int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            ddst[i*n+j] = dist[i][j];
    sort(ddst, ddst + n * n);
    int l = 0, r = unique(ddst, ddst + n * n) - ddst;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(ddst[m])) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(ddst[l])/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

bitset<MAXN> ss[MAXN];
bitset<MAXN> buf;

bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i][j] = true;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                buf.reset();
                buf = ss[i];
                buf &= ss[j];
                if (buf.count() >= 1) return true;
            }
    return false;
}

int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    int l = 0, r = mx + 1;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(m)) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(l)/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <bitset>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

inline int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

struct btset{
    unsigned long long pool[47];
    inline void reset() {
        memset(pool, 0, sizeof pool);
    }
    inline void set(int x) {
        pool[x >> 6] |= ((unsigned long long)1) << (x & ((1 << 6)-1));
    }
};

inline bool org1(btset & a, btset & b) {
    for (int i = 0; i < 47; i++) {
        if ((a.pool[i] & b.pool[i]) != 0) return true;
    }
    return false;
}

btset ss[MAXN];

inline bool check(int v) {
    for (int i = 0; i < n; i++)
        ss[i].reset();
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (dist[i][j] >= v)
                ss[i].set(j);
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (dist[i][j] >= v) {
                if (org1(ss[i], ss[j])) return true;
            }
    return false;
}
int ddst[MAXN*MAXN];
int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    int mx = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) {
            dist[i][j] = fdist(i, j);
            mx = max(mx, dist[i][j]);
        }
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            ddst[i*n+j] = dist[i][j];
    sort(ddst, ddst + n * n);
    int l = 0, r = n*n+1;//unique(ddst, ddst + n * n) - ddst;
    while (l + 1 < r) {
        int m = (l + r) / 2;
        if (check(ddst[m])) l = m;
        else r = m;
    }
    cout.precision(100);
    cout << sqrtl(ddst[l])/2;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
using namespace std;

#define INF 1e+9
#define MAXN 3000
int n;
int x[MAXN];
int y[MAXN];
int dist[MAXN][MAXN];

int fdist(int ii, int jj) {
    return (x[ii]-x[jj])*(x[ii]-x[jj])+(y[ii]-y[jj])*(y[ii]-y[jj]);
}

int main() {
	ios_base::sync_with_stdio(false);
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            dist[i][j] = fdist(i, j);
    int res = 0;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++) {
            int cc = 0;
            for (int t = j + 1; t < n; t++)
                 cc = max(cc, min(dist[i][t], dist[t][j]));
            res = max(res, min(cc, dist[i][j]));
        }
    cout.precision(1000);
    cout << sqrtl(res)/2;
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef float type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const type eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*2];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = 0; i < q; ++i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
  }
  return false;
}

bool solve(type r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((type)d.y, (type)d.x);
          //B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  type lo = 0, hi = 2.6e4, mid;
  for (int i = 0; i < 33; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 8e-8;
    else
      hi = mid + 8e-8;
  }
  printf("%.7f\n", (lo+hi)/4); // :S
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef double type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const double eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*3];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = 0; i < q; ++i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
    /*
    x = B[i] - sixty;
    p = upper_bound(B+i-q+1, B+i, x);
    if (p != B+i-q+1 and pi2-B[i]+*--p >= sixty-eps) {
      //cout << " @" << x << "  " << B[i] << "  " << B[i] - *p << endl;
      return true;
    }
    */
  }
  return false;
}

bool solve(double r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((double)d.y, (double)d.x);
          //B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  type lo = 0, hi = 15e3, mid;
  for (int i = 0; i < 34; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 8e-8;
    else
      hi = mid + 8e-8;
  }
  printf("%.7f\n", (lo+hi)/4); // :S
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef float type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const type eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*2];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = 0; i < q; ++i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
  }
  return false;
}

bool solve(type r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((type)d.y, (type)d.x);
          //B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  type lo = 0, hi = 2.85e4, mid;
  for (int i = 0; i < 34; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 8e-8;
    else
      hi = mid + 8e-8;
  }
  printf("%.7f\n", (lo+hi)/4); // :S
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef float type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const type eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*2];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = 0; i < q; ++i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
  }
  return false;
}

bool solve(type r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((type)d.y, (type)d.x);
          //B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  type lo = 0, hi = 15e3, mid;
  for (int i = 0; i < 34; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 8e-8;
    else
      hi = mid + 8e-8;
  }
  printf("%.7f\n", (lo+hi)/4); // :S
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef float type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const type eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*2];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = 0; i < q; ++i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
  }
  return false;
}

bool solve(type r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((type)d.y, (type)d.x);
          //B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  type lo = 0, hi = 2.6e4, mid;
  for (int i = 0; i < 30; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 8e-8;
    else
      hi = mid + 8e-8;
  }
  printf("%.7f\n", (lo+hi)/4); // :S
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <iostream>
#define MAXN 3001

using namespace std;

typedef double type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const type eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*2];
int sz;
int n, q;

/*
inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = 0; i < q; ++i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
  }
  return false;
}

bool solve(type r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((type)d.y, (type)d.x);
          //B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}
*/

typedef pair<double, int> pdi;
bool order(const pdi &i, const pdi &j) {
  return i.first < j.first;
}
pdi D[MAXN];

int ans;

inline void find(int idx) {
  sort(D, D+q, order);
  sort(B, B+sz);
  multiset<int> S;
  multiset<int>::iterator it;
  type x1, x2;
  int p1 = 1, p2 = 1, t;
  for (int i = 0; i < q; ++i) {
    x1 = B[i] + sixty, x2 = x1 + 4*sixty;
    while (B[p2] <= x2+eps)
      S.insert(D[p2++].second);
    while (B[p1] < x1-eps and p1 < p2) {
      it = S.find(D[p1++].second);
      S.erase(it);
    }
    if (not S.empty()) {
      it = S.end();
      t = min(D[i].second, *--it);
      if (t > ans) {
        /*
        cout << "# " << id+1 << " " << *it << " " << D[i] <<
          " " << i << " " << p1 << " " << p2 << " " << B[i]*180/pi
          << endl;
          */
        ans = t;
      }
    }
  }
}

void solve() {
  type ang;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        ang = atan2((type)d.y, (type)d.x);
        //B[sz++] = ang-pi2-eps;
        B[sz++] = ang;
        B[sz++] = ang+pi2+eps;
        D[q++] = pdi(ang, d.norm2());
      }
    find(i);
  }
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  /*
     type lo = 0, hi = 2.6e4, mid;
     for (int i = 0; i < 33; ++i) {
     mid = (lo+hi)/2;
     if (solve(mid))
     lo = mid - 8e-8;
     else
     hi = mid + 8e-8;
     }
     printf("%.7f\n", (lo+hi)/4); // :S
     */
  ans = 0;
  solve();
  printf("%.7f\n", sqrt(ans) / 2);
}


#include <iostream>
#include <cstring>

using namespace std;

bool cell[11][11];
bool vc[11];
int main() {
  int r, c;
  cin >> r >> c;
  memset(cell, 1, sizeof cell);
  memset(vc, 1, sizeof vc);
  string s;
  int ans = 0;
  for (int i = 0; i < r; i++) {
    bool vr = true;
    cin >> s;
    for (int j = 0; j < c; j++)
      if (s[j] == 'S') {
        vr = false;
        vc[j] = false;
      }
    if (vr)
      for (int j = 0; j < c; j++) {
        ans += cell[i][j];
        cell[i][j] = 0;
      }
  }
  for (int j = 0; j < c; j++)
    if (vc[j])
      for (int i = 0; i < r; i++)
        ans += cell[i][j];
  cout << ans << endl;
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <iostream>
#define MAXN 3001

using namespace std;

typedef float type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const type eps = 1e-10, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
int sz, n, q;

typedef pair<double, int> pdi;
bool order(const pdi &i, const pdi &j) {
  return i.first < j.first;
}
pdi D[MAXN*2];

int ans;

inline void find(int idx) {
  sort(D, D+sz, order);
  multiset<int> S;
  multiset<int>::iterator it;
  type x1, x2;
  int p1 = 1, p2 = 1;
  for (int i = 0; i < q; ++i) {
    x1 = D[i].first + sixty, x2 = x1 + 4*sixty;
    while (p2 < sz and D[p2].first <= x2+eps)
      S.insert(D[p2++].second);
    while (p1 < p2 and D[p1].first < x1-eps) {
      it = S.find(D[p1++].second);
      S.erase(it);
    }
    if (not S.empty()) {
      it = S.end();
      ans = max(ans, min(D[i].second, *--it));
    }
  }
}

void solve() {
  type ang;
  int ds2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        ang = atan2((type)d.y, (type)d.x);
        ds2 = d.norm2();
        if (ds2 > ans) {
          D[sz++] = pdi(ang, ds2);
          D[sz++] = pdi(ang+pi2+eps, ds2);
          ++q;
        }
      }
    find(i);
  }
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  /*
     type lo = 0, hi = 2.6e4, mid;
     for (int i = 0; i < 33; ++i) {
     mid = (lo+hi)/2;
     if (solve(mid))
     lo = mid - 8e-8;
     else
     hi = mid + 8e-8;
     }
     printf("%.7f\n", (lo+hi)/4); // :S
     */
  ans = 0;
  solve();
  printf("%.7f\n", sqrt(ans) / 2);
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef double type;

template<typename T>
struct p2d {
  T x, y;
  p2d(T x = 0, T y = 0) : x(x), y(y) {}
  p2d(const p2d &a) : x(a.x), y(a.y) {}
  p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  p2d operator * (T k) const {
    return p2d(x*k, y*k);
  }
  p2d operator / (T k) const {
    return p2d(x/k, y/k);
  }
  void operator -= (const p2d &a) {
    x -= a.x, y -= a.y;
  }
  void operator += (const p2d &a) {
    x += a.x, y += a.y;
  }
  void operator *= (T k) {
    x *= k, y *= k;
  }
  void operator /= (T k) {
    x /= k, y /= k;
  }
  bool operator == (const p2d &a) const {
    return x == a.x and y == a.y;
  }
  bool operator != (const p2d &a) const {
    return x != a.x or y != a.y;
  }
  bool operator < (const p2d &a) const {
    if (x == a.x)
      return y < a.y;
    return x < a.x;
  }

  T norm2() const {
    return x * x + y * y;
  }
  T norm() const {
    return sqrt(norm2());
  }
  void reduce() {
    T g = __gcd(x, y);
    x /= g, y /= g;
  }
  p2d ort() const {
    return p2d(-y, x);
  }
  T operator % (const p2d &a) const {
    return x * a.y - y * a.x;
  }
  T operator * (const p2d &a) const {
    return x * a.x + y * a.y;
  }
};
typedef p2d<type> pt;
const double eps = 1e-8, pi = atan2(0, -1), sixty = pi / 3;
pt A[MAXN];
type B[MAXN*3];
int sz;
int n, q;

bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = (q << 1)-1; i >= q; --i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and 2*pi-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
    x = B[i] - sixty;
    p = upper_bound(B+i-q+1, B+i, x);
    if (p != B+i-q+1 and 2*pi-B[i]+*--p >= sixty-eps) {
      //cout << " @" << x << "  " << B[i] << "  " << B[i] - *p << endl;
      return true;
    }
  }
  return false;
}

bool solve(double r) {
  type dist, ang;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist = d.norm();
        if (dist >= r) {
          ang = atan2(d.y, d.x);
          B[sz++] = ang-2*pi-eps;
          B[sz++] = ang;
          B[sz++] = ang+2*pi+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  ios::sync_with_stdio(0);
  cin >> n;
  for (int i = 0; i < n; ++i)
    cin >> A[i].x >> A[i].y;
  type lo = 0, hi = 16e3, mid;
  for (int i = 0; i < 40; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 2e-7;
    else
      hi = mid + 2e-7;
  }
  printf("%.7f\n", (lo+hi)/4);
}


#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef double type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm2() const {
    return x * x + y * y;
  }
};
typedef p2d<int> pt;
const double eps = 1e-9, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*3];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = (q << 1)-1; i >= q; --i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
    x = B[i] - sixty;
    p = upper_bound(B+i-q+1, B+i, x);
    if (p != B+i-q+1 and pi2-B[i]+*--p >= sixty-eps) {
      //cout << " @" << x << "  " << B[i] << "  " << B[i] - *p << endl;
      return true;
    }
  }
  return false;
}

bool solve(double r) {
  type r2 = r * r, ang;
  int dist2;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist2 = d.norm2();
        if (dist2 >= r2) {
          ang = atan2((double)d.y, (double)d.x);
          B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i)
    scanf("%d %d", &A[i].x, &A[i].y);
  type lo = 0, hi = 15e3, mid;
  for (int i = 0; i < 34; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 1e-7;
    else
      hi = mid + 1e-7;
  }
  printf("%.7f\n", (lo+hi)/4); // :S
}


#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#define MAXN 3001

using namespace std;

typedef double type;

template<typename T>
struct p2d {
  T x, y;
  inline p2d(T x = 0, T y = 0) : x(x), y(y) {}
  inline p2d(const p2d &a) : x(a.x), y(a.y) {}
  inline p2d operator - (const p2d &a) const {
    return p2d(x-a.x, y-a.y);
  }
  inline p2d operator + (const p2d &a) const {
    return p2d(x+a.x, y+a.y);
  }
  inline T norm() const {
    return hypot(x, y);
  }
};
typedef p2d<type> pt;
const double eps = 1e-8, pi = atan2(0, -1), sixty = pi/3, pi2 = 2*pi;
pt A[MAXN];
type B[MAXN*3];
int sz;
int n, q;

inline bool find() {
  sort(B, B+sz);
  type x, *p;
  for (int i = (q << 1)-1; i >= q; --i) {
    x = B[i] + sixty;
    p = lower_bound(B+i+1, B+i+q, x);
    if (p != B+i+q and pi2-*p+B[i] >= sixty-eps) {
      //cout << " #" << x << "  " << B[i] << "  " << *p - B[i] << endl;
      return true;
    }
    x = B[i] - sixty;
    p = upper_bound(B+i-q+1, B+i, x);
    if (p != B+i-q+1 and pi2-B[i]+*--p >= sixty-eps) {
      //cout << " @" << x << "  " << B[i] << "  " << B[i] - *p << endl;
      return true;
    }
  }
  return false;
}

bool solve(double r) {
  type dist, ang;
  for (int i = 0; i < n; ++i) {
    sz = q = 0;
    for (int j = 0; j < n; ++j)
      if (i != j) {
        pt d = A[j] - A[i];
        dist = d.norm();
        if (dist >= r) {
          ang = atan2(d.y, d.x);
          B[sz++] = ang-pi2-eps;
          B[sz++] = ang;
          B[sz++] = ang+pi2+eps;
          ++q;
        }
      }
    if (q and find()) {
      //cout << "> " << i+1 << " " <<  r << endl;
      return true;
    }
  }
  return false;
}

int main() {
  ios::sync_with_stdio(0);
  cin >> n;
  for (int i = 0; i < n; ++i)
    cin >> A[i].x >> A[i].y;
  type lo = 0, hi = 15e3, mid;
  for (int i = 0; i < 35; ++i) {
    mid = (lo+hi)/2;
    if (solve(mid))
      lo = mid - 2e-7;
    else
      hi = mid + 2e-7;
  }
  printf("%.7f\n", (lo+hi)/4);
}


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

const int aa = 28;

int x[3333],y[3333];
int flag[3333][333];
pair <int,int> a[9000011];
int step[40];
int ansx[9000011],ansy[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

void ins(int x,int y)
{
    int z,t;
    if (y%aa==0) z = y / aa; else z = y / aa + 1;
    if (y%aa==0) t = aa; else t = y%aa;
    flag[x][z]+=step[t-1];
}

bool solve(int a,int b)
    {
        return (a&b)>0;
    }

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                step[0]=1;
                for (int i = 1; i<=28; i++) step[i]=step[i-1]*2;
                cin >> n;
                int ans = 0;
                if (n%aa==0) ans = n / aa; else ans = n / aa + 1;
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                        ansx[(i-1)*n+j]=i;
                        ansy[(i-1)*n+j]=j;
                  }
                }
                sort(a,a+cnt,mycomp);
                memset(flag,0,sizeof(flag));
                for (int i = 0; i<cnt; i++)
                {
                    int xx = ansx[a[i].second];
                    int yy = ansy[a[i].second];
                    //cout << xx << yy << endl;
                    for (int k = 1; k<=ans; k++)
                    if (solve(flag[xx][k],flag[yy][k]))
                    {
                        cout.precision(10);
                        double answer = a[i].first * 1.0;
                        answer = sqrt(answer)/2.0;
                        cout << answer << endl;
                        return 0;
                    }
                  ins(xx,yy);
                  ins(yy,xx);
                }
                return 0;
            }


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

int x[3333],y[3333];
int flag[3333][333];
pair <int,int> a[9000011];
int step[40];
int ansx[9000011],ansy[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

void ins(int x,int y)
{
    int z,t;
    if (y%16==0) z = y / 16; else z = y / 16 + 1;
    if (y%16==0) t = 16; else t = y%16;
    flag[x][z]+=step[t-1];
}

bool solve(int a,int b)
    {
        return (a&b)>0;
    }

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                step[0]=1;
                for (int i = 1; i<=28; i++) step[i]=step[i-1]*2;
                cin >> n;
                int ans = 0;
                if (n%16==0) ans = n / 16; else ans = n / 16 + 1;
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                        ansx[(i-1)*n+j]=i;
                        ansy[(i-1)*n+j]=j;
                  }
                }
                sort(a,a+cnt,mycomp);
                memset(flag,0,sizeof(flag));
                for (int i = 0; i<cnt; i++)
                {
                    int xx = ansx[a[i].second];
                    int yy = ansy[a[i].second];
                    //cout << xx << yy << endl;
                    for (int k = 1; k<=ans; k++)
                    if (solve(flag[xx][k],flag[yy][k]))
                    {
                        cout.precision(10);
                        double answer = a[i].first * 1.0;
                        answer = sqrt(answer)/2.0;
                        cout << answer << endl;
                        return 0;
                    }
                  ins(xx,yy);
                  ins(yy,xx);
                }
                return 0;
            }


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

int x[3333],y[3333];
int flag[3333][333];
pair <int,int> a[9000011];
int ansx[9000011],ansy[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

void ins(int x,int y)
{
    int z,t;
    if (y%16==0) z = y / 16; else z = y / 16 + 1;
    if (y%16==0) t = 16; else t = y%16;
    flag[x][z]+=(1<<(t-1));
}

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                cin >> n;
                int ans = 0;
                if (n%16==0) ans = n / 16; else ans = n / 16 + 1;
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                        ansx[(i-1)*n+j]=i;
                        ansy[(i-1)*n+j]=j;
                  }
                }
                sort(a,a+cnt,mycomp);
                memset(flag,0,sizeof(flag));
                for (int i = 0; i<cnt; i++)
                {
                    int xx = ansx[a[i].second];
                    int yy = ansy[a[i].second];
                    //cout << xx << yy << endl;
                    for (int k = 1; k<=ans; k++)
                        if (flag[xx][k]&flag[yy][k]>0)
                    {
                        cout.precision(10);
                        double answer = a[i].first * 1.0;
                        answer = sqrt(answer)/2.0;
                        cout << answer << endl;
                        return 0;
                    }
                  ins(xx,yy);
                  ins(yy,xx);
                }
                return 0;
            }


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

int x[3333],y[3333];
int used[3333][3333];
pair <int,int> a[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                cin >> n;
                memset(used,0,sizeof(used));
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                    }
                }
                sort(a,a+cnt,mycomp);
                for (int i = 0; i<cnt; i++)
                {
                    int dist = a[i].first;
                    int cur = a[i].second;
                    int xx,yy;
                    if (cur%n==0)
                    {
                        xx = cur/n;
                        yy = n;
                    } else
                    {
                        xx = cur/n + 1;
                        yy = cur%n;
                    }
                   used[xx][yy]=dist;
                   used[yy][xx]=dist;
                   for (int k = 1; k<=n; k++)
                   {
                       if (k==xx || k == yy) continue;
                       if (used[xx][k]!=0 && used[yy][k]!=0)
                       {
                           cout.precision(10);
                           //cout << dist << endl;
                           double answer = sqrt(dist*1.0)/2.0;
                           cout << answer << endl;
                           return 0;
                       }
                   }
                }
                return 0;
            }


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

const int aa = 30;

int x[3333],y[3333];
int flag[3333][333];
pair <int,int> a[9000011];
int step[40];
int ansx[9000011],ansy[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

void ins(int x,int y)
{
    int z,t;
    if (y%aa==0) z = y / aa; else z = y / aa + 1;
    if (y%aa==0) t = aa; else t = y%aa;
    flag[x][z]+=step[t-1];
}

bool solve(int a,int b)
    {
        return (a&b)>0;
    }

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                step[0]=1;
                for (int i = 1; i<=28; i++) step[i]=step[i-1]*2;
                cin >> n;
                int ans = 0;
                if (n%aa==0) ans = n / aa; else ans = n / aa + 1;
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                        ansx[(i-1)*n+j]=i;
                        ansy[(i-1)*n+j]=j;
                  }
                }
                sort(a,a+cnt,mycomp);
                memset(flag,0,sizeof(flag));
                for (int i = 0; i<cnt; i++)
                {
                    int xx = ansx[a[i].second];
                    int yy = ansy[a[i].second];
                    //cout << xx << yy << endl;
                    for (int k = 1; k<=ans; k++)
                    if (solve(flag[xx][k],flag[yy][k]))
                    {
                        cout.precision(10);
                        double answer = a[i].first * 1.0;
                        answer = sqrt(answer)/2.0;
                        cout << answer << endl;
                        return 0;
                    }
                  ins(xx,yy);
                  ins(yy,xx);
                }
                return 0;
            }


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

int x[3333],y[3333];
int flag[3333][333];
pair <int,int> a[9000011];
int step[40];
int ansx[9000011],ansy[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

void ins(int x,int y)
{
    int z,t;
    if (y%16==0) z = y / 16; else z = y / 16 + 1;
    if (y%16==0) t = 16; else t = y%16;
    flag[x][z]+=step[t-1];
}

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                step[0]=1;
                for (int i = 1; i<=28; i++) step[i]=step[i-1]*2;
                cin >> n;
                int ans = 0;
                if (n%16==0) ans = n / 16; else ans = n / 16 + 1;
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                        ansx[(i-1)*n+j]=i;
                        ansy[(i-1)*n+j]=j;
                  }
                }
                sort(a,a+cnt,mycomp);
                memset(flag,0,sizeof(flag));
                for (int i = 0; i<cnt; i++)
                {
                    int xx = ansx[a[i].second];
                    int yy = ansy[a[i].second];
                    //cout << xx << yy << endl;
                    for (int k = 1; k<=ans; k++)
                        if (flag[xx][k]&&flag[yy][k]>0)
                    {
                        cout.precision(10);
                        double answer = a[i].first * 1.0;
                        answer = sqrt(answer)/2.0;
                        cout << answer << endl;
                        return 0;
                    }
                  ins(xx,yy);
                  ins(yy,xx);
                }
                return 0;
            }


#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <map>
#include <cmath>
#include <queue>
#include <algorithm>
#include <set>

using namespace std;

int x[3333],y[3333];
int used[3333][3333];
pair <int,int> a[9000011];
int ansx[9000011],ansy[9000011];

bool mycomp(pair <int,int> a,pair <int,int> b)
{
    return a.first>b.first;
}

int main()
            {
                //freopen("input.txt","r",stdin);
                //freopen("output.txt","w",stdout);
                int n;
                cin >> n;
                memset(used,0,sizeof(used));
                for (int i = 1; i<=n; i++)
                  cin >> x[i] >> y[i];
                int cnt = 0;
                for (int i = 1; i<=n; i++)
                {
                    for (int j = i + 1; j<=n; j++)
                    {
                        cnt++;
                        a[cnt-1].first=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
                        a[cnt-1].second=(i-1)*n+j;
                        ansx[(i-1)*n+j]=i;
                        ansy[(i-1)*n+j]=j;
                    }
                }
                sort(a,a+cnt,mycomp);
                for (int i = 0; i<cnt; i++)
                {
                    int dist = a[i].first;
                    int cur = a[i].second;
                    int xx,yy;
                    xx=ansx[cur];
                    yy=ansy[cur];
                   used[xx][yy]=dist;
                   used[yy][xx]=dist;
                   for (int k = 1; k<=n; k++)
                   {
                       if (k==xx || k == yy) continue;
                       if (used[xx][k]!=0 && used[yy][k]!=0)
                       {
                           cout.precision(10);
                           //cout << dist << endl;
                           double answer = sqrt(dist*1.0)/2.0;
                           cout << answer << endl;
                           return 0;
                       }
                   }
                }
                return 0;
            }


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
//  ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

// bool check(pnt p1, pnt p2, int r){
//     return (p1 - p2).len2() >= r;
// }

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    if (bsz == 0) return 0;
    int r1 = two_far_point();

    return r1 >= r;
//     if (r1 >= r){
//  assert(check(c[ansp.fr], c[ansp.sc], r));
//  return 1;
//     }
//     return 0;
   // return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n, m;
int bsz = 0;
pnt v1, v2;

inline bool cmp(pnt p1, pnt p2){
    v1 = (p1 - b[0]);
    v2 = (p2 - b[0]);
    return v1 * v2 > 0 || (v1 * v2 == 0 && v1.len2() < v2.len2());
//     return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 2; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
//  ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
        ansp = mp(cur1, cur2);
    }

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool check(pnt p1, pnt p2, int r){
    return (p1 - p2).len2() >= r;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    if (bsz == 0) return 0;
    int r1 = two_far_point();
    if (r1 >= r){
    assert(check(c[ansp.fr], c[ansp.sc], r));
    return 1;
    }
    return 0;
   // return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
	return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
	return x * a.y - y * a.x;
    }
    int  len2(){
	return x * x + y * y;
    }
    void Epr(){
// 	epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
	if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
	    swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
	for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
	c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
	ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
// 	if ((c[cur1] - c[cur2]).len2() > ans2){
// 	    ans2 = (c[cur1] - c[cur2]).len2();
// 	    ansp = mp(cur1, cur2);
// 	}

	v1 = c[(cur1 + 1) % sz] - c[cur1];
	v2 = c[(cur2 + 1) % sz] - c[cur2];
	if (v1 * v2 >= 0)
	    cur2 = (cur2 + 1) % sz;
	else
	    cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

// bool check(pnt p1, pnt p2, int r){
//     return (p1 - p2).len2() >= r;
// }

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
	if ((a[v] - a[i]).len2() >= r)
	    b[bsz++] = a[i];

    if (bsz == 0) return 0;
    int r1 = two_far_point();

    return r1 >= r;
//     if (r1 >= r){
//	assert(check(c[ansp.fr], c[ansp.sc], r));
// 	return 1;
//     }
//     return 0;
   // return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
	cin >> a[i].x >> a[i].y;
	// 	scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
	for(int j = 0; j < n; j++)
	    dist[j] = (a[i] - a[j]).len2();
	sort(dist, dist + n);
	int l = 0;
	int r = n;
	while(r - l > 1){
	    if (solve(i, dist[(l + r) / 2]))
		l = (l + r) / 2;
	    else
		r = (l + r) / 2;
	}
// 	epr("l: %d\n\n", l);
	ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <cmath>
#include <utility>
#include <algorithm>
#define X first
#define Y second
#define DO int
#define REP(i,n) for (int i=1;i<=n;++i)
using namespace std;

pair<DO,DO> a[3030];
int n;
DO ans;

inline DO Dist(int x,int y) {
    return ((a[x].X-a[y].X)*(a[x].X-a[y].X)+(a[x].Y-a[y].Y)*(a[x].Y-a[y].Y));
    return 0;
}

int main() {
    scanf("%d",&n);
    REP(i,n)
        scanf("%d%d",&a[i].X,&a[i].Y);
    sort(a+1,a+n+1);
    REP(i,1000000) {
        int x=rand()%n+1;
        int y=rand()%n+1;
        int z=rand()%n+1;
        ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    }
    for (int x=n;x;--x)
        REP(y,x-1)
            if (Dist(x,y)>ans) REP(z,y)
                ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    printf("%.20lf\n",sqrt(ans)/2);
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
//pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
//     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
  /*  for(int i = 0; i < sz; i++)
    c[i].Epr();
   */
    for(int i = 0; i < sz * 3; i++){
    assert(cur1 >= 0 && cur1 < sz);
    assert(cur2 >= 0 && cur2 < sz);

    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
//     epr("ans2 %d\n", ans2);
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (const pnt & a){
    return pnt(x - a.x, y - a.y);
    }
    inline int operator * (const pnt & a)const{
    return x * a.y - y * a.x;
    }
    inline int len2() const{
    return x * x + y * y;
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;

inline int Dist(const pnt & a, const pnt & b){
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

inline bool cmp(const pnt & p1, const pnt & p2){
    return p1 * p2 > 0 || (p1 * p2 == 0 && p1.len2() < p2.len2());
    //     return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

inline int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    for(int i = bsz - 1; i != -1; i--)
    b[i] = b[i] - b[0];

    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz + 5; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

inline bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = Dist(a[i], a[j]);
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprlong longf(stderr, __VA_ARGS__)

const long long maxn = 10003;
const long long inf = 1e9;

struct pnt{
    long long x, y;
    pnt(){}
    pnt(long long x, long long y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    long long operator * (pnt a){
    return x * a.y - y * a.x;
    }
    long long  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
long long dist[maxn];
long long n;
long long bsz = 0;
pair < long long, long long > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

long long two_far_point(){
    for(long long i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    long long sz = 0;
    for(long long i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    long long cur1 = 0, cur2 = 0;
    long long ans2 = 0;
    pnt v1, v2;
    for(long long i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(long long v, long long r){
    bsz = 0;

    for(long long i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    long long ans2 = 0;
//     scanf("%d", &n);
    cin >> n;
    for(long long i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(long long i = 0; i < n; i++){
    for(long long j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    long long l = 0;
    long long r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n, m;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
//  ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
        ansp = mp(cur1, cur2);
    }

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool check(pnt p1, pnt p2, int r){
    return (p1 - p2).len2() >= r;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    if (bsz == 0) return 0;
    int r1 = two_far_point();
    if (r1 >= r){
    assert(check(c[ansp.fr], c[ansp.sc], r) && check(c[ansp.fr], a[v], r) && check(a[v], c[ansp.sc], r));
    return 1;
    }
    return 0;
   // return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
//     cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n, m;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
//  if ((c[cur1] - c[cur2]).len2() > ans2){
//      ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
//  }

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

// bool check(pnt p1, pnt p2, int r){
//     return (p1 - p2).len2() >= r;
// }

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    long long x, y;
    pnt(){}
    pnt(long long x, long long y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    long long operator * (pnt a){
    return x * a.y - y * a.x;
    }
    long long  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
long long dist[maxn];
int n;
int bsz = 0;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
//     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    long long ans2 = 0;
    pnt v1, v2;
  /*  for(int i = 0; i < sz; i++)
    c[i].Epr();
   */
    for(int i = 0; i < sz * 3; i++){
    assert(cur1 >= 0 && cur1 < sz);
    assert(cur2 >= 0 && cur2 < sz);

    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
//     epr("ans2 %d\n", ans2);
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    long long ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;

    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
        ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}
bool check(pnt p1, pnt p2, int r){
    return (p1 - p2).len2() >= r;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}