#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);++i)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;--i)
#define lb lower_bound
#define ub upper_bound
#define ENDL '\n'
typedef pair<int,int> Pi;
typedef pair<ll,ll> PL;
const ll mod = 1000000007;
const ll INF = 1000000099;
const ll LINF = (ll)(1e18 +99);
const vector<ll> dx={-1,1,0,0},dy={0,0,-1,1};
template<typename T,typename U> inline bool chmin(T& t, const U& u){if(t>u){t=u;return 1;}return 0;}
template<typename T,typename U> inline bool chmax(T& t, const U& u){if(t<u){t=u;return 1;}return 0;}
template<typename T> inline T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T,typename Y> inline T mpow(T a, Y n) {
  T res = 1;
  for(;n;n>>=1) {
    if (n & 1) res = res * a;
    a = a * a;
  }
  return res;
}

template<typename T>
vector<T> finddivisor(T x){//整数xの約数が入ったvectorを返すよ(xを含む)  
    vector<T> divisor;
    for(T i=1; (i*i)<=x ;i++)
    {
        if(x%i==0){
            divisor.push_back(i);
            if(i*i!=x){
                divisor.push_back(x/i);
            }//約数はペアを持つことを利用

        }
    }
    sort(divisor.begin(),divisor.end());
    //divisor.push_back(x);
    return divisor;
}

#define EPS 1e-8

int eql(db a){return fabs(a)<EPS;}
int eql(db a,db b){return eql(a-b);}

struct P{
  db x,y;
  P(db _x=db(),db _y=db()):x(_x),y(_y){}
  //デフォルトはdoubleのデフォルト引数

  P operator+(const P& r)const{return {x+r.x,y+r.y};}
  P operator-(const P& r)const{return {x-r.x,y-r.y};}
  P operator*(const double a)const{return {x*a,y*a};}
  P operator/(const double a)const{return {x/a,y/a};}

  P& operator+=(const P& r) {return *this = *this+r;}
  P& operator-=(const P& r) {return *this = *this-r;}
  P& operator*=(const db& r) {return *this = *this*r;}
  P& operator/=(const db& r) {return *this = *this/r;}

  bool operator==(const P& r)const{return eql(x-r.x) && eql(y-r.y);}
  bool operator<(const P& r)const{
    if(eql(x,r.x))return y<r.y;
    else return x<r.x;
  }

  db norm(){
    return x*x+y*y;
  }//大きさの二乗

  db abs(){
    return sqrt(norm());
  }//大きさ

};//Point

struct L{
  P a,b;
  L(db _ax,db _ay,db _bx,db _by):L(P(_ax,_ay),P(_bx,_by)){}
  L(P _a,P _b):a(_a),b(_b){}
};

db dot(P a,P b){
  return a.x*b.x + a.y*b.y;
}//dot product 内積

db crs(P a,P b){
  return a.x*b.y-a.y*b.x;
}//cross product 外積

int ccw(P a,P b){
  if(crs(a,b)>EPS)return -1;
  if(crs(a,b)<-EPS)return 1;
  if(dot(a,b)<-EPS)return 2;
  if(a.norm()<b.norm())return -2;
  return 0;
}
//counter clockwise
//-2,-1,0,1,2 : online_front,cw,on,counter_cw,online_back
int ccw(P a,P b,P c){
  return ccw(b-a,c-a);
}

bool intersect(P p1,P p2,P p3,P p4){
  return ccw(p1,p2,p3)*ccw(p1,p2,p4)<=0 && ccw(p3,p4,p1)*ccw(p3,p4,p2)<=0;
}
bool intersect(L a,L b){
  return intersect(a.a,a.b,b.a,b.b);
}//線分交差判定



P cent(P& A, P& B,P& C){
    db x1=A.x,y1=A.y,x2=B.x,y2=B.y,x3=C.x,y3=C.y;

		double a = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
		double b = sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));
		double c = sqrt((x1-x3)*(x1-x3)+(y1-y3)*(y1-y3));
		double S = sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))/4;
		
		double x = (a*a* (b*b+c*c-a*a)*x3 + b*b* (c*c+a*a-b*b)*x1 + c*c*(a*a+b*b-c*c)*x2)/(16*S*S);
		double y = (a*a* (b*b+c*c-a*a)*y3 + b*b* (c*c+a*a-b*b)*y1 + c*c*(a*a+b*b-c*c)*y2)/(16*S*S);
    P ans;ans.x=x,ans.y=y;

		return ans;
}




signed main(){
  cin.tie(0);ios::sync_with_stdio(false);
  cout<<fixed<<setprecision(20);
  ll n;cin>>n;
  
  V<P> v(n);
  db ans=INF;

  rep(i,0,n)cin>>v[i].x>>v[i].y;

  rep(i,0,n-2)rep(j,i+1,n-1)rep(k,j+1,n){
    if(abs(ccw(v[i],v[j],v[k]))==2)continue;

    db a,b,c;
    a=pow(pow(v[i].x-v[j].x,2)+pow(v[i].y-v[j].y,2),0.5);
    b=pow(pow(v[i].x-v[k].x,2)+pow(v[i].y-v[k].y,2),0.5);
    c=pow(pow(v[k].x-v[j].x,2)+pow(v[k].y-v[j].y,2),0.5);

    db r=(a)*(b)*(c);
  
    db bb=pow((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c),0.5);
    r/=bb;
    

    P C=cent(v[i],v[j],v[k]);
    db dis;
    bool ok=true;
    rep(l,0,n){
      //cerr<<C.x<<" "<<(v[l].x-C.x)<<" "<<(v[l].y-C.y)<<" ";
      dis=(v[l].x-C.x)*(v[l].x-C.x)+(v[l].y-C.y)*(v[l].y-C.y);
      //cerr<<r*r<<" "<<dis<<ENDL;
      if(pow(r,2)+EPS<dis)ok=false;
    }

    if(ok)chmin(ans,r);
  }
cerr<<ans<<ENDL;
  rep(i,0,n-1)rep(j,i+1,n){
    P C={(v[i].x+v[j].x)/2,(v[i].y+v[j].y)/2};
    db dis,r=(v[i].x-C.x)*(v[i].x-C.x)+(v[i].y-C.y)*(v[i].y-C.y);
    bool ok=true;
    rep(l,0,n){
      dis=(v[l].x-C.x)*(v[l].x-C.x)+(v[l].y-C.y)*(v[l].y-C.y);
      if(r+EPS<dis)ok=false;
    }
    if(ok)chmin(ans,pow(r,0.5));
  }

  cout<<ans<<ENDL;
}
//( ・ __ ・ ) KEEP BEING ORGANIZED
//CHECK overflow,vector_size,what to output?

//div2 C

Measured memory_bytes: 256