#include <bits/stdc++.h>

#define rep(i,n) for(int i=0;i<(n);i++)

using namespace std;

class Real{
	using T=long double;
	constexpr static T EPS=1e-10;
	T x;
public:
	Real(const T& x=0):x(x){}
	Real& operator+=(const Real& r){ x+=r.x; return *this; }
	Real& operator-=(const Real& r){ x-=r.x; return *this; }
	Real& operator*=(const Real& r){ x*=r.x; return *this; }
	Real& operator/=(const Real& r){ x/=r.x; return *this; }
	Real operator+(const Real& r)const{ return Real(*this)+=r; }
	Real operator-(const Real& r)const{ return Real(*this)-=r; }
	Real operator*(const Real& r)const{ return Real(*this)*=r; }
	Real operator/(const Real& r)const{ return Real(*this)/=r; }
	Real operator-()const{ return Real(-x); }
	bool operator< (const Real& r)const{ return x<r.x-EPS; }
	bool operator> (const Real& r)const{ return r<(*this); }
	bool operator<=(const Real& r)const{ return !(r<(*this)); }
	bool operator>=(const Real& r)const{ return !((*this)<r); }
	bool operator==(const Real& r)const{ return !((*this)<r) && !(r<(*this)); }
	bool operator!=(const Real& r)const{ return (*this)<r || r<(*this); }

	friend Real operator*(const T& c,const Real& r){ return r*c; }

	friend istream& operator>>(istream& is,Real& r){ T s; is>>s; r=Real(s); return is; }
	friend ostream& operator<<(ostream& os,const Real& r){ return os<<r.x; }

	friend Real abs  (const Real& r){ return abs(r.x); }
	friend Real sqrt (const Real& r){ return sqrt(r.x); }
	friend Real cos  (const Real& r){ return cos(r.x); }
	friend Real sin  (const Real& r){ return sin(r.x); }
	friend Real atan2(const Real& y,const Real& x){ return atan2(y.x,x.x); }
};

const Real PI=acos(-1.0L);

class point{
public:
	Real x,y;
	point(){}
	point(const Real& x,const Real& y):x(x),y(y){}
	point& operator+=(const point& p){ x+=p.x; y+=p.y; return *this; }
	point& operator-=(const point& p){ x-=p.x; y-=p.y; return *this; }
	point& operator*=(const Real& c){ x*=c; y*=c; return *this; }
	point& operator/=(const Real& c){ x/=c; y/=c; return *this; }
	point operator+(const point& p)const{ return point(*this)+=p; }
	point operator-(const point& p)const{ return point(*this)-=p; }
	point operator*(const Real& c)const{ return point(*this)*=c; }
	point operator/(const Real& c)const{ return point(*this)/=c; }
	point operator-()const{ return point(-x,-y); }
	bool operator< (const point& p)const{ return tie(x,y)<tie(p.x,p.y); }
	bool operator==(const point& p)const{ return x==p.x && y==p.y; }
	bool operator!=(const point& p)const{ return !((*this)==p); }

	friend point operator*(const Real& c,const point& p){ return p*c; }
};

Real dot  (const point& p,const point& q){ return p.x*q.x+p.y*q.y; }
Real cross(const point& p,const point& q){ return p.x*q.y-p.y*q.x; }

Real abs (const point& p){ return sqrt(p.x*p.x+p.y*p.y); }
Real abs2(const point& p){ return p.x*p.x+p.y*p.y; }

class circle{
public:
	point c;
	Real r;
	circle(){}
	circle(const point& c,const Real& r):c(c),r(r){}
};

bool cover(const circle &C,const point &p){
	return abs(C.c-p)<=C.r;
}

class smallest_enclosing_circle{
	random_device seed_gen;
	mt19937 rng;

	vector<point> P;

	// 境界にある点集合
	int n_bd;
	point bd[3];

	// {bd[0], ..., bd[n_bd-1]} の最小包含円を求める
	circle naive(){
		if(n_bd==0) return circle(point(0,0),-1);

		// Gram-Schmidt で使う作業用
		point v[2]; // v[i] := (v[0], ..., v[i-1] と直交するベクトル)
		Real z[2]; // z[i] := |v[i]|^2

		// (cen, sqrt(R2)) := ({bd[0], ..., bd[i]} の最小包含円)
		point cen=bd[0];
		Real R2=0;
		rep(i,n_bd-1){
			point delta=bd[i+1]-cen;

			// Gram-Schmidt
			v[i]=delta;
			rep(j,i) v[i]-=dot(v[j],delta)/z[j]*v[j];
			z[i]=dot(v[i],v[i]);

			Real mag=abs2(delta)-R2;
			cen+=mag/(2*z[i])*v[i];
			R2+=mag*mag/(4*z[i]);
		}

		return circle(cen,sqrt(R2));
	}

	circle dfs(int i){
		if(i==P.size() || n_bd==3) return naive();

		// P[i] を境界として使わない場合
		circle C=dfs(i+1);
		// P[i] を境界として使う場合
		if(C.r==-1 || !cover(C,P[i])){
			bd[n_bd++]=P[i];
			C=dfs(i+1);
			n_bd--;
		}
		return C;
	}

public:
	smallest_enclosing_circle(const vector<point>& P):rng(seed_gen()),P(P){}
	circle find(){
		n_bd=0;
		shuffle(P.begin(),P.end(),rng);
		return dfs(0);
	}
};

int main(){
	int n; cin>>n;
	vector<point> P(n);
	rep(i,n) cin>>P[i].x>>P[i].y;

	cout<<setprecision(9)<<smallest_enclosing_circle(P).find().r<<'\n';

	return 0;
}


Measured memory_bytes: 512