#include <bits/stdc++.h>
using namespace std;
using Real = double;
constexpr Real EPS = 1e-8;

template<typename T> inline int sign(T a) { return a < -EPS ? -1 : a > EPS; }
template<typename T> inline int cmp(T a, T b) { return sign(a - b); }
constexpr int RAND_SEED = 0x94845;
struct Point {
  Real x, y;
  Point() = default;
  Point(Real x, Real y) : x(x), y(y) {}
  Point operator+(Point rhs) const { return Point(x + rhs.x, y + rhs.y); }
  Point operator-(Point rhs) const { return Point(x - rhs.x, y - rhs.y); }
  Point operator*(Real rhs) const { return Point(x * rhs, y * rhs); }
  Point operator/(Real rhs) const { return Point(x / rhs, y / rhs); }
  bool operator<(Point rhs) const {
    int c = cmp(x, rhs.x);
    if (c) return c == -1;
    return cmp(y, rhs.y) == -1;
  }
  Real dot(Point rhs) const { return x * rhs.x + y * rhs.y; }
  Real det(Point rhs) const { return x * rhs.y - y * rhs.x; }
  Real angle() const { return std::atan2(y, x); }
  Real abs2() const { return x * x + y * y; }
  Real abs() const { return std::sqrt(abs2()); }
  Real distTo(Point rhs) const { return (*this - rhs).abs(); }
  Point orthogonal() const { return Point(-y, x); }
  Point unit() const { return *this / abs(); }
  Point rotate(Real theta) const {
    return Point(std::cos(theta) * x - std::sin(theta) * y, std::sin(theta) * x + std::cos(theta) * y);
  }
  int quad() const { return sign(y) == 1 || (sign(y) == 0 && sign(x) >= 0); }
  friend std::istream &operator>>(std::istream &in, Point &p) { return in >> p.x >> p.y; }
  friend std::ostream &operator<<(std::ostream &out, const Point &p) { return out << p.x << ", " << p.y; }
};

struct Circle {
  Point center;
  double r2;
  Circle(const Point &center, double r2) : center(center), r2(r2) {}
  Circle() = default;
  bool contains(const Point &p) const { return (p - center).abs2() <= r2; }
};

Circle get_circumcircle(const Point &a, const Point &b, const Point &c) {
  Point AC = c - a, AB = b - a;
  Point center = a + (AC * AB.abs2() - AB * AC.abs2()).orthogonal() / (2 * AC.det(AB));
  return Circle(center, (center - a).abs2());
}

Circle get_circumcircle(const Point &a, const Point &b) {
  return Circle((a + b) / 2, (a - b).abs2() / 4);
}

Circle smallest_encloing_disc_with_two_points(std::vector<Point> &points, Point q1, Point q2) {
  Circle circle = get_circumcircle(q1, q2);
  for (std::size_t i = 0; i < points.size(); ++i) {
    if (!circle.contains(points[i])) {
      circle = get_circumcircle(q1, q2, points[i]);
    }
  }
  return circle;
}

Circle smallest_encloing_disc_with_point(std::vector<Point> &points, Point q) {
  std::shuffle(points.begin(), points.end(), std::mt19937(RAND_SEED));
  Circle circle = get_circumcircle(points[0], q);
  for (std::size_t i = 1; i < points.size(); ++i) {
    if (!circle.contains(points[i])) {
      std::vector<Point> P(std::begin(points), std::begin(points) + i);
      circle = smallest_encloing_disc_with_two_points(P, points[i], q);
    }
  }
  return circle;
}

Circle smallest_enclosing_disc(std::vector<Point> points) {
  std::shuffle(points.begin(), points.end(), std::mt19937(RAND_SEED));
  Circle circle = get_circumcircle(points[0], points[1]);
  for (std::size_t i = 2; i < points.size(); ++i) {
    if (!circle.contains(points[i])) {
      std::vector<Point> P(std::begin(points), std::begin(points) + i);
      circle = smallest_encloing_disc_with_point(P, points[i]);
    }
  }
  return circle;
}
int main() {
  int n;
  cin >> n;
  vector<Point> points(n);
  for (auto &pt : points) cin >> pt.x >> pt.y;
  auto ret = smallest_enclosing_disc(points);
  cout << fixed << setprecision(15) << sqrt(ret.r2) << '\n';
  return 0;
}

Measured memory_bytes: 256