#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}

int nextInt() { int x; scanf("%d", &x); return x;}
ll nextLong() { ll x; scanf("%lld", &x); return x;}

using D = long double;
const D PI = acos(-1.0);
const D EPS = 1e-10;
struct P {
  D x, y;
  P(D x=0, D y=0) : x(x), y(y) {}

  P& operator+=(const P& o) { x += o.x; y += o.y; return *this; }
  P& operator-=(const P& o) { x -= o.x; y -= o.y; return *this; }
  P& operator*=(const P& o) { return *this = {x*o.x - y*o.y, x*o.y + y*o.x}; }
  P& operator*=(const D& r) { x *= r; y *= r; return *this; }
  P& operator/=(const D& r) { x /= r; y /= r; return *this; }
  P operator-() const { return {-x, -y}; }

  D norm() const { return x*x + y*y; }
  D abs() const { return sqrt(norm()); }
  D arg() const { return atan2(y, x); }
  bool isZero() const { return std::abs(x) < EPS && std::abs(y) < EPS; }
  /** 象限 */
  int orth() const { return y >= 0 ? (x >= 0 ? 1 : 2) : (x < 0 ? 3 : 4); }
  static P polar(const D& rho, const D& theta = 0) { return {rho * cos(theta), rho * sin(theta)}; }
};
std::ostream &operator<<(std::ostream &os, P const &p) { return os << "(" << p.x << ", " << p.y << ")"; }
std::istream &operator>>(std::istream &is, P &p) { D a, b; is >> a >> b; p = P(a, b); return is; }
P operator+(const P& p, const P& q) { return P(p) += q; }
P operator-(const P& p, const P& q) { return P(p) -= q; }
P operator*(const P& p, const P& q) { return P(p) *= q; }
P operator*(const P& p, const D& r) { return P(p) *= r; }
P operator/(const P& p, const D& r) { return P(p) /= r; }
P operator*(const D& r, const P& p) { return P(p) *= r; }
P operator/(const D& r, const P& p) { return P(p) /= r; }
D crs(const P& a, const P& b){ return a.x*b.y - a.y*b.x; }
D dot(const P& a, const P& b){ return a.x*b.x + a.y*b.y; }


struct C : public P {
  D r;
  C() {}
  C(const P &p, D r):P(p),r(r){}
};

C circleThreePoints(P a, P b, P c){
  b-=a,c-=a;
  P x=P(b.x, c.x);
  P y=P(b.y, c.y);
  P p=P(b.norm(), c.norm())/2.0;

  if (abs(crs(x, y)) < 0.000000001) throw 1;
  P center=P(crs(p,y),crs(x,p))/crs(x,y)+a;
  return C( center , (center - a).abs() );
}

int main2() {
  int N = nextInt();

  vector<P> ps(N);
  REP(i, N) {
    double x = nextInt();
    double y = nextInt();
    ps[i] = P(x, y);
  }

  const double EPS = 1e-8;


  vector<C> cs;
  REP(i, N) {
    for (int j = i + 1; j < N; j++) {
      P m = (ps[i] + ps[j]) / 2.0;
      D d = (ps[i] - ps[j]).abs();
      cs.push_back( (C){ m, d/2 } );
    }
  }

  REP(i, N) {
    for (int j = i + 1; j < N; j++) {
      for (int k = j + 1; k < N; k++) {
        try {
          C circle = circleThreePoints(ps[i], ps[j], ps[k]);
          cs.push_back(circle);
        } catch (int x) {
        }
      }
    }
  }

  double ans = 999999999;
  for (C circle : cs) {
    bool ok = true;
    REP(l, N) {
      if ((ps[l] - circle).abs() > circle.r + EPS)
        ok = false;
    }
    if (ok) {
      chmin(ans, (double)circle.r);
    }
  }

  printf("%.10f\n", ans);
  return 0;
}

int main() {

#ifdef LOCAL
  for (;!cin.eof();cin>>ws)
#endif
    main2();
  return 0;
}


Measured memory_bytes: 1912