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

using CP = complex<long double>;
#define X real()
#define Y imag()
const long double PI = acos(-1.0L);
const long double EPS = 1e-10;
// conj(x) : complex conjugate,(0,1)->(0,-1)
// abs(x) : dist between(0,0) and x
// norm(x) : abs(x) * abs(x)
// arg(x) : argment
long double dot(CP a, CP b) { return (a * conj(b)).X; }
long double cross(CP a, CP b) { return (a * conj(b)).Y; }
long double corner(CP a, CP b) {
  //[0,pi]
  return acos(dot(a, b) / (abs(a) * abs(b)));
}

CP intersection(CP a, CP b, CP c, CP d) {
  return a + (b - a) * (cross(d - c, c - a) /
                        cross(d - c, b - a));
}

bool on_seg(CP a, CP b, CP p) {
  // if not use end point, dot(a - p, b - p) < 0
  return abs(cross(a - p, b - p)) <= 1e-10 &&
         dot(a - p, b - p) <= 0;
}

// crossing lines? (a,b) and (c,d)
bool iscross(CP a, CP b, CP c, CP d) {
  // parallel
  if(abs(cross(a - b, c - d)) <= 1e-10) {
    return on_seg(a, b, c) || on_seg(a, b, d) ||
           on_seg(c, d, a) || on_seg(c, d, b);
  }
  CP isp = intersection(a, b, c, d);
  return on_seg(a, b, isp) && on_seg(c, d, isp);
}

long double distLP(CP a, CP b, CP p) {
  return abs(cross(b - a, p - a) / abs(b - a));
}

// segmentver.
long double distSP(CP a, CP b, CP p) {
  if(dot(b - a, p - a) < 0) return abs(p - a);
  if(dot(a - b, p - b) < 0) return abs(p - b);
  return distLP(a, b, p);
}

// segment and segment
long double distSS(CP a, CP b, CP c, CP d) {
  long double res = 1e18;
  res = min(res, distSP(a, b, c));
  res = min(res, distSP(a, b, d));
  res = min(res, distSP(c, d, a));
  res = min(res, distSP(c, d, b));
  return res;
}

struct convex_hull {
  vector<CP> ch;
  int psize;
  convex_hull() {}
  convex_hull(vector<CP> &ps) { calculation(ps); }
  void calculation(vector<CP> &ps) {
    auto lmd = [&](const CP &l, const CP &r) {
      if(l.X != r.X) return l.X < r.X;
      return l.Y < r.Y;
    };
    psize = ps.size();
    sort(ps.begin(), ps.end(), lmd);
    int k = 0;
    ch.resize(psize * 2);
    for(int i = 0; i < psize; ++i) {
      while(k > 1 && cross(ch[k - 1] - ch[k - 2],
                           ps[i] - ch[k - 1]) <= 0)
        --k;
      ch[k++] = ps[i];
    }
    for(int i = psize - 2, t = k; i >= 0; --i) {
      while(k > t && cross(ch[k - 1] - ch[k - 2],
                           ps[i] - ch[k - 1]) <= 0)
        --k;
      ch[k++] = ps[i];
    }
    ch.resize(k - 1);
    psize = ch.size();
  }
};

long long n;
vector<CP> v;
convex_hull ch;

long double solve();

int main() {
  cout << fixed << setprecision(10);
  cin >> n;
  for(int i = 0; i < n; ++i) {
    int x, y;
    cin >> x >> y;
    v.push_back(CP(x, y));
  }
  cout << solve() << endl;
  return 0;
}

long double solve() {
  if(n == 2) return abs(v[0] - v[1]) / 2;
  long double res = 1e18;
  // ch = convex_hull(v);
  // n = ch.ch.size();
  for(int i = 0; i < n; ++i)
    for(int j = i + 1; j < n; ++j) {
      CP g = v[i] - v[j];
      g /= 2;
      g += v[j];
      long double r = abs(v[i] - v[j]) / 2;
      bool nowch = 1;
      for(int i = 0; i < n; ++i)
        if(abs(v[i] - g) - r > EPS) nowch = 0;
      if(nowch) res = min(res, r);
    }
  for(int i = 0; i < n; ++i)
    for(int j = i + 1; j < n; ++j)
      for(int k = j + 1; k < n; ++k) {
        CP a = v[i], b = v[j], c = v[k], g;
        CP ab, bc, ten(0.0L, -1.0L), tmp, ab2, bc2;
        ab = b - a;
        ab /= 2.0L;
        tmp = ab;
        tmp *= ten;
        ab += a;
        ab2 = ab + tmp;
        bc = b - c;
        bc /= 2.0L;
        tmp = bc;
        tmp *= ten;
        bc += c;
        bc2 = bc + tmp;
        g = intersection(ab, ab2, bc, bc2);

        long double r = abs(g - a);
        // assert(abs(r - abs(g - b)) <= EPS);
        // assert(abs(r - abs(g - c)) <= EPS);
        bool nowch = 1;
        for(int i = 0; i < n; ++i)
          if(abs(v[i] - g) - r > EPS) nowch = 0;
        if(nowch) res = min(res, r);
      }
  return res;
}

Measured memory_bytes: 384