#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define IFOR(i,a,b) for(int i=(b-1);i>=(a);--i)
#define RPT(i,a,b) for(int i=(a);i<((a)+(b));++i)
#define IRPT(i,a,b) for(int i=((a)+(b)-1);i>=(a);--i)
constexpr int INF = (1 << 29);
constexpr ll INF_ = (1LL << 58);
constexpr ld EPS = (1e-10);
constexpr ld PI_ = 3.141592653589793238;//46264338327950288
constexpr ld E_ = 2.71828182845904523;//5360287471352
// COUNTER CLOCKWISE
constexpr int CCW_COUNTER_CLOCKWISE = 1;
constexpr int CCW_CLOCKWISE = -1;
constexpr int CCW_ONLINE_BACK = 2; // B-A-C
constexpr int CCW_ONLINE_FRONT = -2; // C-B-A
constexpr int CCW_ON_SEGMENT = 0;// B-C-A
// intercsect of circles
constexpr int ICC_SEPERATE = 4;
constexpr int ICC_CIRCUMSCRIBE = 3;
constexpr int ICC_INTERSECT = 2;
constexpr int ICC_INSCRIBE = 1;
constexpr int ICC_CONTAIN = 0;
ld epscut(ld x){
  if((x>0 && x<EPS)||(x<0 && x>-EPS)){
    x = 0.0;
  }
  return x;
}
//// data types (Geometry)_______________________________
struct Point{
  ld x, y;
  Point(ld x, ld y) : x(x), y(y) {}
  Point() : x(0.0), y(0.0)  {}
  Point operator+(const Point &p){
    return {x+p.x, y+p.y};
  }
  Point operator-(const Point &p){
    return {x-p.x, y-p.y};
  }  
  Point operator*(const ld k){
    return {k*x, k*y};
  }
  Point operator/(const ld k){
    return {x/k, y/k};
  }
  ld operator*(const Point &p){
    return x*p.x+y*p.y;
  }
  ld operator^(const Point &p){
    return x*p.y-y*p.x;
  }
  bool operator==(const Point &p){
    return (epscut(x-p.x)==0) && (epscut(y-p.y)==0);
  }
};
struct Circle{
  Point p; ld r;
  Circle(Point c,ld r):p(c),r(r){}
  Circle(ld x, ld y, ld r): p(Point(x,y)),r(r) {}
};
struct Line{
  Point p1, p2;
  Line(Point p1, Point p2): p1(p1), p2(p2) {}
  Line(ld x1, ld y1, ld x2, ld y2): p1(Point(x1,y1)), p2(Point(x2,y2)) {}
};
using Polygon = vector<Point>;
using Segment = Line;
////-----------------------------------------------------
//// functions (Geometry)________________________________
ld Norm(Point p);
ld Inner(Point p1, Point p2);
ld Outer(Point p1, Point p2);
int PointSortX(Point p1, Point p2);
int PointSortY(Point p1, Point p2);
Point Rotate(Point p, ld theta, Point o);
Point VerPoint(Point p, int a);
void Point_cout(Point p);
bool isOrthogonal(Point a,Point b);
bool isOrthogonal(Point a1,Point a2,Point b1,Point b2);
bool isOrthogonal(Line s1,Line s2);
bool isParallel(Point a,Point b);
bool isParallel(Point a1,Point a2,Point b1,Point b2);// is (a2-a1) <-parallel-> (b2-b1)
bool isParallel(Line s1,Line s2);
Point project(Line s,Point p);
Point reflect(Line s,Point p);
ld arg(Point p);
Point polar(ld a, ld r);
int ccw(Point a, Point b, Point c);
bool intersectSS(Point p1,Point p2,Point p3,Point p4);
bool intersectSS(Line s1,Line s2);
bool intersectPS(Polygon p,Line l);
int intersectCC(Circle c1,Circle c2);
bool intersectSC(Segment s,Circle c);
ld getDistanceLP(Line l,Point p);
ld getDistanceSP(Segment s,Point p);
ld getDistanceSS(Segment s1,Segment s2);
Point getCrossPointSS(Segment s1,Segment s2);
Point getCrossPointLL(Line l1,Line l2);
Polygon getCrossPointCL(Circle c,Line l);
Polygon getCrossPointCS(Circle c,Segment s);
Polygon getCrossPointCC(Circle c1,Circle c2);
int contains(Polygon g,Point p);// IN:2 ON:1 OUT:0
////-----------------------------------------------------
//// functions (Geometry)________________________________
ld Norm(Point p){
  return ((p.x*p.x+p.y*p.y));
}
ld Inner(Point p1, Point p2){
  return (p1.x*p2.x + p1.y*p2.y);
}
ld Outer(Point p1, Point p2){
  return (p1.x*p2.y-p1.y*p2.x);
}
int PointSortX(Point p1, Point p2){
  return ((p1.x!=p2.x)?(p1.x<p2.x):(p1.y<p2.y));
}
int PointSortY(Point p1, Point p2){
  return ((p1.y!=p2.y)?(p1.y<p2.y):(p1.x<p2.x));
}
Point Rotate(Point p, ld theta, Point o = Point(0,0)){
  ld x, y;
  x = o.x + (p.x-o.x)*cos(theta) - (p.y-o.y)*sin(theta);
  y = o.y + (p.x-o.x)*sin(theta) + (p.y-o.y)*cos(theta);
  return Point(x,y);
}
Point VerPoint(Point p, int a){/* VerPoint(p,1) = Rotate(p,PI_/2), VerPoint(p,-1) = Rotate(p,-PI_/2)  */
  if(a==1)return Point(-p.y,p.x);
  else if(a==-1) return Point(p.y,-p.x);
  else return p;
}
void Point_cout(Point p){
  cout << "(" << p.x << "," << p.y << ")" ;
}
bool isOrthogonal(Point a,Point b){
  return (epscut(a*b)==0.0);
}
bool isOrthogonal(Point a1,Point a2,Point b1,Point b2){
  return isOrthogonal(a1-a2,b1-b2);
}
bool isOrthogonal(Line s1,Line s2){
  return (epscut( (s1.p2-s1.p1)*(s2.p2-s2.p1) )==0.0);
}
bool isParallel(Point a,Point b){
  return (epscut(a^b)==0.0);
}
bool isParallel(Point a1,Point a2,Point b1,Point b2){
  return isParallel(a1-a2,b1-b2);
}
bool isParallel(Line s1,Line s2){
  return (epscut( (s1.p2-s1.p1)^(s2.p2-s2.p1) )==0.0);
}
Point project(Line s,Point p){
  Point base=s.p2-s.p1;
  ld r=((p-s.p1)*(base))/Norm(base);
  return s.p1+base*r;
}
Point reflect(Line s,Point p){
  return p+(project(s,p)-p)*2.0;
}
ld arg(Point p){
  return atan2(p.y,p.x);
}
Point polar(ld a, ld r){
  return Point(cos(r)*a,sin(r)*a);
}
int ccw(Point a, Point b, Point c){
  b = b - a; c = c - a;
  if(epscut(b^c)>0) return CCW_COUNTER_CLOCKWISE; // anti-clock
  if(epscut(b^c)<0) return CCW_CLOCKWISE; // clock
  if(epscut(b*c)<0) return CCW_ONLINE_BACK;// b-a-c
  if(epscut(Norm(b)-Norm(c))<0) return CCW_ONLINE_FRONT; // a-c-b
  return CCW_ON_SEGMENT; // a-b-c
}
bool intersectSS(Point p1,Point p2,Point p3,Point p4){
  return (ccw(p1,p2,p3)*ccw(p1,p2,p4) <= 0 &&
          ccw(p3,p4,p1)*ccw(p3,p4,p2) <= 0 );
}
bool intersectSS(Line s1,Line s2){
  return intersectSS(s1.p1,s1.p2,s2.p1,s2.p2);
}
bool intersectPS(Polygon p,Line l){
  int n=p.size();
  for(int i=0;i<n;i++)
    if(intersectSS(Line(p[i],p[(i+1)%n]),l)) return 1;
  return 0;
}
int intersectCC(Circle c1,Circle c2){
  if(c1.r<c2.r) swap(c1,c2);
  ld d=sqrt(Norm(c1.p-c2.p));
  ld r=c1.r+c2.r;
  if(epscut(d-r)==0) return ICC_CIRCUMSCRIBE;
  if(epscut(d-r)>0) return ICC_SEPERATE;
  if(epscut(d+c2.r-c1.r)==0) return ICC_INSCRIBE;
  if(epscut(d+c2.r-c1.r)<0) return ICC_CONTAIN;
  return ICC_INTERSECT;
}
bool intersectSC(Line s,Circle c){
  return getDistanceSP(s,c.p)<=c.r;
}
ld getDistanceLP(Line l,Point p){
  return abs(((l.p2-l.p1)^(p-l.p1))/sqrt(Norm(l.p2-l.p1)));
}
ld getDistanceSP(Segment s,Point p){
  if(epscut((s.p2-s.p1)*(p-s.p1)) < 0.0 ) return sqrt(Norm(p-s.p1));
  if(epscut((s.p1-s.p2)*(p-s.p2)) < 0.0 ) return sqrt(Norm(p-s.p2));
  return getDistanceLP(s,p);
}
ld getDistanceSS(Segment s1,Segment s2){
  if(intersectSS(s1,s2)) return 0.0;
  return min(min(getDistanceSP(s1,s2.p1),getDistanceSP(s1,s2.p2)),
             min(getDistanceSP(s2,s1.p1),getDistanceSP(s2,s1.p2)));
}
Point getCrossPointSS(Segment s1,Segment s2){
  for(int k=0;k<2;k++){
    if(epscut(getDistanceSP(s1,s2.p1))<=0.0) return s2.p1;
    if(epscut(getDistanceSP(s1,s2.p2))<=0.0) return s2.p2;
    swap(s1,s2);
  }
  Point base=s2.p2-s2.p1;
  ld d1=abs(((base)^(s1.p1-s2.p1)));
  ld d2=abs(((base)^(s1.p2-s2.p1)));
  ld t=d1/(d1+d2);
  return s1.p1+(s1.p2-s1.p1)*t;
}
Point getCrossPointLL(Line l1,Line l2){
  ld a=((l1.p2-l1.p1)^(l2.p2-l2.p1));
  ld b=((l1.p2-l1.p1)^(l1.p2-l2.p1));
  if(epscut(a)<=0.0&&epscut(b)<=0.0) return l2.p1;
  return l2.p1+(l2.p2-l2.p1)*(b/a);
}
Polygon getCrossPointCL(Circle c,Line l){
  Polygon ps;
  Point pr=project(l,c.p);
  Point e=(l.p2-l.p1)/sqrt(Norm(l.p2-l.p1));
  if(epscut(getDistanceLP(l,c.p)-c.r)==0.0){
    ps.emplace_back(pr);
    return ps;
  }
  ld base=sqrt(c.r*c.r-Norm(pr-c.p));
  ps.emplace_back(pr+e*base);
  ps.emplace_back(pr-e*base);
  return ps;
}
Polygon getCrossPointCS(Circle c,Segment s){
  Line l(s);
  Polygon res=getCrossPointCL(c,l);
  if(intersectSC(s,c)==2) return res;// intersectCS(c,s) --> intersectSC(s,c)
  if(res.size()>1u){
    if(epscut((l.p1-res[0])*(l.p2-res[0]))>0) swap(res[0],res[1]);
    res.pop_back();
  }
  return res;
}
Polygon getCrossPointCC(Circle c1,Circle c2){
  Polygon p(2);
  ld d=sqrt(Norm(c1.p-c2.p));
  ld a=acos((c1.r*c1.r+d*d-c2.r*c2.r)/(2*c1.r*d));
  ld t=arg(c2.p-c1.p);
  p[0]=c1.p+polar(c1.r,t+a);
  p[1]=c1.p+polar(c1.r,t-a);
  return p;
}
int contains(Polygon g,Point p){
  int n=g.size();
  bool x=false;
  for(int i=0;i<n;i++){
    Point a=g[i]-p,b=g[(i+1)%n]-p;
    if(epscut(fabs(a^b)) <= 0.0 && epscut(a*b) <= 0.0) return 1;
    if(a.y>b.y) swap(a,b);
    if(epscut(a.y) <= 0.0 && epscut(b.y) >= 0.0 && epscut(a^b) >= 0.0 ) x = !x;
  }
  return (x?2:0);
}
////-----------------------------------------------------





int main(void){
  int N; vector<Point> pts;
  cin.tie(0);
  ios::sync_with_stdio(false);
  std::cout << std::fixed << std::setprecision(15);
  cin >> N;
  RPT(i,0,N){
    ld x,y;
    cin >> x >> y;
    pts.push_back(Point(x,y));
  }
  if(N==2){
    cout << sqrt(Norm((pts[0]-pts[1])/2)) << endl;
    return 0;
  }
  else{
    ld left = 0.0, right = 708;
    while((right - left)>1e-9){
      ld mid = (left + right)/2;int psbl = 0;
      FOR(i,0,N){
        FOR(j,(i+1),N){
          Circle c1(pts[i],mid), c2(pts[j],mid); //Point_cout(Point(i,j)); cout << endl;
          int i_s_ = intersectCC(c1,c2);
          if(pts[i].x==pts[j].x && pts[i].y==pts[j].y) i_s_ = ICC_CIRCUMSCRIBE;
          switch(i_s_){
            case ICC_INTERSECT : {
              Polygon X = getCrossPointCC(c1,c2);
              int tmpcheck = 1;
              FOR(k,0,N){
                if(k == i || k == j) continue; //cout << sqrt(Norm(pts[k]-X[0])) << endl;
                if( epscut( sqrt(Norm(pts[k]-X[0])) - mid )>0  ){
                  tmpcheck = 0;
                }
              }
              if(tmpcheck){
                psbl = 1;
                i = 98765432;
                j = 98765432;
              }
              tmpcheck = 1;
              FOR(k,0,N){
                if(k == i || k == j) continue; //cout << sqrt(Norm(pts[k]-X[0])) << endl;
                if( epscut( sqrt(Norm(pts[k]-X[1])) - mid )>0  ){
                  tmpcheck = 0;
                }
              }
              if(tmpcheck){
                psbl = 1;
                i = 98765432;
                j = 98765432;
              }
            }
            case ICC_CIRCUMSCRIBE : {
              Polygon X = getCrossPointCC(c1,c2);
              int tmpcheck = 1;
              FOR(k,0,N){
                if(k == i || k == j) continue;
                if( epscut( sqrt(Norm(pts[k]-X[0])) - mid )>0  ){
                  tmpcheck = 0;
                }
              }
              if(tmpcheck){
                psbl = 1;
                i = 98765432;
                j = 98765432;
              }
            }
            default : {
            }
          }
        }
      }//cout << psbl <<endl;
      if(psbl) right = mid;
      else left = mid;
    }
    cout << right << endl;
  }
  return 0;
}

Measured memory_bytes: 256