#include <cstdio>

#include <cstring>

#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
//#include <queue>
//#include <stack>
#include <cassert>

#include <cmath>

using namespace std;

#define SZ(a) int((a).size())
#define REP(i,n) for(int i=0,_n=(n);i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)

#define DEBUG(x) cerr << #x << ": " << x << endl

typedef long long llong;
typedef vector<int> VI;
typedef vector<VI> VVI;

const double INF = 1e18;
const double EPS = 1e-9;

template<typename T>
struct Point {
   T x, y;
   Point(T _x = 0, T _y = 0) : x(_x), y(_y) {}
   Point(const Point<T>& p) : x(p.x), y(p.y) {}

   Point<T>& operator=( const Point<T>& p );
   bool operator==( const Point<T>& p ) const;
   bool operator!=(const Point<T>& p) const;
   bool operator<(const Point<T>& p) const;

   Point<T>& operator+=( Point<T> p );
   Point<T>  operator+ ( Point<T> p ) const;

   Point<T>& operator-=( Point<T> p );
   Point<T>  operator- ( Point<T> p ) const;

   Point<T>& operator*=( T a );
   Point<T>  operator* ( T a );

   T operator*( Point<T> p ) const;

   T operator^( Point<T> p ) const;

   T squared_mag() const;
   double mag() const;
};

template<typename T>
inline Point<T>& Point<T>::operator=( const Point<T>& p ) {
   if ( &p != this ) {
      x = p.x;
      y = p.y;
   }
   return *this;
}

template<typename T>
inline bool Point<T>::operator==(const Point<T>& p) const {
   return x == p.x && y == p.y;
}

template<typename T>
inline bool Point<T>::operator!=(const Point<T>& p) const {
   return !(*this == p);
// return x != p.x || y != p.y;
}

template<typename T>
inline bool Point<T>::operator<(const Point<T>& p) const {
   return x < p.x || x == (p.x && y < p.y);
}

template<typename T>
inline Point<T>& Point<T>::operator+=( Point<T> p ) {
   x += p.x;
   y += p.y;
   return *this;
}

template<typename T>
inline Point<T>& Point<T>::operator-=( Point<T> p ) {
   x -= p.x;
   y -= p.y;
   return *this;
}

template<typename T>
inline Point<T>& Point<T>::operator*=( T a ) {
   x *= a;
   y *= a;
   return *this;
}
   
template<typename T>
inline Point<T> Point<T>::operator*( T a ) {
   Point<T> res( *this );
   return res *= a;
}

template<typename T>
inline Point<T> Point<T>::operator+( Point<T> p ) const {
   Point<T> res( *this );
   return res += p;
}

template<typename T>
inline Point<T> Point<T>::operator-( Point<T> p ) const {
   Point<T> res( *this );
   return res -= p;
}


template<typename T>
inline T Point<T>::operator*( Point<T> p ) const {
   return x*p.x + y*p.y;
}

template<typename T>
inline T Point<T>::operator^( Point<T> p ) const {
   return x*p.y - y*p.x;
}

template<typename T>
inline T Point<T>::squared_mag() const {
   return x*x + y*y;
}

template<typename T>
inline double Point<T>::mag() const {
   return sqrt( x*x + y*y );
}

Point<double> circum_center(Point<double> A, Point<double> B, double& radius) {
   radius = (A-B).mag() / 2;
   return (A+B)*0.5;
}

// http://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates
Point<double> circum_center(
   Point<double> A, Point<double> B, Point<double> C,
   double &radius
) {
   Point<double> Bp = B - A;
   Point<double> Cp = C - A;
   double Dp = 2 * (Bp ^ Cp);
   if (abs(Dp) < EPS) {
      radius = -1;   // return an invalid circle
      return Point<double>(0, 0);
   }
   Point<double> Up(
      ( Cp.y * Bp.squared_mag() - Bp.y * Cp.squared_mag() ) / Dp,
      ( Bp.x * Cp.squared_mag() - Cp.x * Bp.squared_mag() ) / Dp
   );
   radius = Up.mag();
   return Up + A;
}


#define MAXN 52
int N;
Point<double> P[MAXN];

double solve() {
   if (N == 1)
      return 0.0;

   double res = INF;

   FOR(i, 0, N-1) {
      FOR(j, i+1, N-1) {
         double r;
         Point<double> center = circum_center(P[i], P[j], r);
         assert(!::isnan(r));
         if (::isinf(r) || r >= INF)
            continue;
         double r2 = r*r;
         bool ok = true;
         REP(n, N) {
            if ((P[n]-center).squared_mag() > r2 + EPS) {
               ok = false;
               break;
            }
         }
         if (ok)
            res = min(res, r);
      }
   }

   FOR(i, 0, N-1) {
      FOR(j, i+1, N-1) {
         FOR(k, j+1, N-1) {
            double r;
            Point<double> center = circum_center(P[i], P[j], P[k], r);
            assert(!::isnan(r));
            if (::isinf(r) || r >= INF)
               continue;
            double r2 = r*r;
            bool ok = true;
            REP(n, N) {
               if ((P[n]-center).squared_mag() > r2 + EPS) {
                  ok = false;
                  break;
               }
            }
            if (ok)
               res = min(res, r);
         }
      }
   }

   return res;
}

int main(int argc, char* argv[]) {
   scanf("%d", &N);
   assert(2 <= N && N <= 50);
   REP(i, N) {
      int x, y;
      scanf("%d %d", &x, &y);
      assert(0 <= x && x <= 1000);
      assert(0 <= y && y <= 1000);
      P[i].x = x;
      P[i].y = y;
   }

   double res = solve();
   assert(!::isinf(res) && res < INF);
   printf("%.18f\n", res);

   return 0;
}


Measured memory_bytes: 128