// luogu-judger-enable-o2

//#pragma comment(linker, "/STACK:1024000000,1024000000")



#include<stdio.h>

#include<string.h>

#include<math.h>



//#include<map>

#include<set>

#include<deque>

#include<queue>

#include<stack>

#include<bitset>

#include<string>

#include<fstream>

#include<iostream>

#include<algorithm>

using namespace std;



#define ll long long

#define Pair pair<int,int>

//#define max(a,b) (a)>(b)?(a):(b)

//#define min(a,b) (a)<(b)?(a):(b)

#define clean(a,b) memset(a,b,sizeof(a))// 水印

//std::ios::sync_with_stdio(false);

//  register

const int MAXN=1e5+10;

const int INF32=0x3f3f3f3f;

const ll INF64=0x3f3f3f3f3f3f3f3f;

const int MOD=998244353;

const double PI=acos(-1.0);

const double EPS=1.0e-10;



struct Point{

	double x,y;

	Point(double _x=0,double _y=0){

		x=_x;y=_y;

	}

	friend Point operator + (const Point &a,const Point &b){

		return Point(a.x+b.x,a.y+b.y);

	}

	friend Point operator - (const Point &a,const Point &b){

		return Point(a.x-b.x,a.y-b.y);

	}

	friend double operator ^ (Point a,Point b){

		return a.x*b.y-a.y*b.x;

	}

}Dots[MAXN];

struct V{

	Point start,end;double ang;

	V(Point _start=Point(0,0),Point _end=Point(0,0),double _ang=0.0){

		start=_start;end=_end;ang=_ang;

	}

	friend V operator + (const V &a,const V &b){

		return V(a.start+b.start,a.end+b.end);

	}

	friend V operator - (const V &a,const V &b){

		return V(a.start-b.start,a.end-b.end);

	}

};

struct Circle{

	double r;

	Point centre;

	Circle(Point _centre=Point(0,0),double _r=0){

		centre=_centre;r=_r;

	}

}AnsCir;

struct Triangle{

	Point p[3];

};



int Parellel(const V &x,const V &y){

	return fabs((x.end-x.start)^(y.end-y.start))<EPS;

}

Point LineInterDot(const V &l1,const V &l2){

	Point p;

	double S1=(l2.end-l1.start)^(l2.start-l1.start);

	double S2=(l2.start-l1.end)^(l2.end-l1.end);

	p.x=(l1.start.x*S2+l1.end.x*S1)/(S1+S2);

	p.y=(l1.start.y*S2+l1.end.y*S1)/(S1+S2);

	return p;

}

double Distance(Point p1,Point p2){

	p2=p2-p1;

	return sqrt(p2.x*p2.x+p2.y*p2.y);

}

double TriangleArea(Triangle t){

	return fabs((t.p[1]-t.p[0])^(t.p[2]-t.p[0]))/2.0;

}

Circle CircumCircleOfTriangle(const Triangle &t){

	Circle tmp;

	double a,b,c,c1,c2;

	double xa,ya,xb,yb,xc,yc;

	a=Distance(t.p[0],t.p[1]);b=Distance(t.p[1],t.p[2]);c=Distance(t.p[2],t.p[0]);

	tmp.r=a*b*c/TriangleArea(t)/4.0;

	xa=t.p[0].x;ya=t.p[0].y;

	xb=t.p[1].x;yb=t.p[1].y;

	xc=t.p[2].x;yc=t.p[2].y;

	c1=(xa*xa+ya*ya-xb*xb-yb*yb)/2.0;

	c2=(xa*xa+ya*ya-xc*xc-yc*yc)/2.0;

	tmp.centre.x=(c1*(ya-yc)-c2*(ya-yb))/((xa-xb)*(ya-yc)-(xa-xc)*(ya-yb));

	tmp.centre.y=(c1*(xa-xc)-c2*(xa-xb))/((ya-yb)*(xa-xc)-(ya-yc)*(xa-xb));

	return tmp;

}

Circle MinCircle2(int u,Triangle t){

	if(u==0) return Circle(Point(0,0),-2);

	else if(u==1) return Circle(t.p[0],0);

	else if(u==2) return Circle(Point((t.p[0].x+t.p[1].x)/2.0,(t.p[0].y+t.p[1].y)/2.0),Distance(t.p[0],t.p[1])/2.0);

	else if(u==3) return CircumCircleOfTriangle(t);

}

void MinCircle(int n,int u,Triangle t){

	AnsCir=MinCircle2(u,t);

	if(u==3) return ;

	for(int i=1;i<=n;++i){

		if(Distance(Dots[i],AnsCir.centre)>AnsCir.r+EPS){

			t.p[u]=Dots[i];

			MinCircle(i-1,u+1,t);

			Point temp=Dots[i];

			for(int j=i;j>=2;--j){

				Dots[j]=Dots[j-1];

			}Dots[1]=temp;

		}

	}

}

int main(){

	int n;scanf("%d",&n);

	for(int i=1;i<=n;++i){

		scanf("%lf%lf",&Dots[i].x,&Dots[i].y);

	}Triangle t;

	MinCircle(n,0,t);

	//printf("%.2lf %.2lf %.2lf\n",AnsCir.centre.x,AnsCir.centre.y,AnsCir.r);

	printf("%.6lf\n",AnsCir.r);

}

/*



*/


Measured memory_bytes: 1792