#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

template <typename T>
struct pt {
  T x, y;
  pt() : x(), y() {}
  pt(T nx, T ny) : x(nx), y(ny) {}
  bool operator < (const pt &o) const {
    return x < o.x || (x == o.x && y < o.y);
  }
  bool operator == (const pt &o) const {
    return x == o.x && y == o.y;
  }
};

template <typename T>
pt<T> mkpt(T x, T y) {
  return pt<T>(x, y);
}

template <typename T1, typename T2>
auto operator + (const pt<T1> &p, const pt<T2> &q) {
  return mkpt(p.x + q.x, p.y + q.y);
}

template <typename T1, typename T2>
auto operator - (const pt<T1> &p, const pt<T2> &q) {
  return mkpt(p.x - q.x, p.y - q.y);
}

template <typename T1, typename T2>
auto operator * (const pt<T1> &p, const T2 &v) {
  return mkpt(p.x * v, p.y * v);
}

template <typename T1, typename T2>
auto operator * (const T1 &v, const pt<T2> &p) {
  return mkpt(p.x * v, p.y * v);
}

template <typename T1, typename T2>
auto operator / (const pt<T1> &p, const T2 &v) {
  return mkpt(p.x / v, p.y / v);
}

template <typename T1, typename T2>
auto dot(const pt<T1> &p, const pt<T2> &q) {
  return p.x * q.x + p.y * q.y;
}

template <typename T1, typename T2>
auto cross(const pt<T1> &p, const pt<T2> &q) {
  return p.x * q.y - p.y * q.x;
}

template <typename T>
auto norm2(const pt<T> &p) {
  return dot(p, p);
}

template <typename T>
auto norm(const pt<T> &p) {
  return sqrt(norm2(p));
}

template <typename T>
auto unit(const pt<T> &p) {
  return p / norm(p);
}

template <typename T1, typename T2>
auto dist2(const pt<T1> &p, const pt<T2> &q) {
  return norm2(p - q);
}

template <typename T1, typename T2>
auto dist(const pt<T1> &p, const pt<T2> &q) {
  return norm(p - q);
}

template <typename T>
pt<T> rotateccw90(const pt<T> &p) {
  return pt<T>(-p.y, p.x);
}

template <typename T>
struct ln {
  pt<T> p, pq;
  ln() {}
  ln(const pt<T> &np, const pt<T> &nq) : p(np), pq(nq - np) {}
  pt<T> q() const {
    return p + pq;
  }
};

template <typename T1, typename T2>
pt<double> intersect_lines(const ln<T1> &a, const ln<T2> &b) {
  return a.p + a.pq * ((double)cross(b.p - a.p, b.pq) / cross(a.pq, b.pq));
}

template <typename T>
ln<double> bisector(const ln<T> &s) {
  auto a = (s.p + s.q()) * 0.5;
  return ln<double>(a, a + rotateccw90(a - s.p));
}

int n;
pt<int> p[59];

bool check(pt<double> s, double r) {
  for (int i = 0; i < n; ++i) {
    if (dist(s, p[i]) > r + 1e-10) {
      return false;
    }
  }
  return true;
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    int x, y;
    scanf("%d%d", &x, &y);
    p[i] = pt<int>(x, y);
  }
  double ans = 1e100;
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      pt<double> s = (p[i] + p[j]) * 0.5;
      double r = dist(s, p[i]);
      if (check(s, r)) {
        ans = min(ans, r);
      }
    }
  }
  for (int i = 0; i < n; ++i) {
    for (int j = i + 1; j < n; ++j) {
      for (int k = j + 1; k < n; ++k) {
        if (cross(p[j] - p[i], p[k] - p[i]) == 0) {
          continue;
        }
        pt<double> s = intersect_lines(bisector(ln<int>(p[i], p[j])), bisector(ln<int>(p[j], p[k])));
        double r = dist(s, p[i]);
        if (check(s, r)) {
          ans = min(ans, r);
        }
      }
    }
  }
  printf("%.15f\n", ans);
}


Measured memory_bytes: 128