#include <bits/stdc++.h>
// #define int int64_t

#define FOR(i, a, b) for (int i = (a); i < int(b); ++i)
#define RFOR(i, a, b) for (int i = (b)-1; i >= int(a); --i)
#define rep(i, n) FOR(i, 0, n)
#define rep1(i, n) FOR(i, 1, int(n) + 1)
#define rrep(i, n) RFOR(i, 0, n)
#define rrep1(i, n) RFOR(i, 1, int(n) + 1)
#define all(c) begin(c), end(c)
namespace io {
#ifdef LOCAL
#define dump(...)                                     \
  do {                                                \
    std::ostringstream os;                            \
    os << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
    io::print_to(os, ", ", "\n", __VA_ARGS__);        \
    std::cerr << io::highlight(os.str());             \
  } while (0)
#define dump_(cntnr)                             \
  do {                                           \
    std::ostringstream os;                       \
    os << __LINE__ << ":\t" << #cntnr << " = ["; \
    io::print_to_(os, ", ", "]\n", all(cntnr));  \
    std::cerr << io::highlight(os.str());        \
  } while (0)
#define dumpf(fmt, ...)                         \
  do {                                          \
    const int N = 4096;                         \
    auto b = new char[N];                       \
    int l = snprintf(b, N, "%d:\t", __LINE__);  \
    snprintf(b + l, N - l, fmt, ##__VA_ARGS__); \
    std::cerr << io::highlight(b) << std::endl; \
    delete[] b;                                 \
  } while (0)
#else
#define dump(...)
#define dump_(...)
#define dumpf(...)
#endif
std::string highlight(std::string s) {
#ifdef _MSC_VER
  return s;
#else
  return "\033[33m" + s + "\033[0m";
#endif
}
template <typename T>
void print_to(std::ostream &os, std::string, std::string tail, const T &first) {
  os << first << tail;
}
template <typename F, typename... R>
void print_to(std::ostream &os, std::string del, std::string tail,
              const F &first, const R &... rest) {
  os << first << del;
  print_to(os, del, tail, rest...);
}
template <typename I>
void print_to_(std::ostream &os, std::string del, std::string tail, I begin,
               I end) {
  for (I it = begin; it != end;) {
    os << *it;
    os << (++it != end ? del : tail);
  }
}
template <typename F, typename... R>
void println(const F &first, const R &... rest) {
  print_to(std::cout, "\n", "\n", first, rest...);
}
template <typename F, typename... R>
void print(const F &first, const R &... rest) {
  print_to(std::cout, " ", "\n", first, rest...);
}
template <typename I>
void println_(I begin, I end) {
  print_to_(std::cout, "\n", "\n", begin, end);
}
template <typename I>
void print_(I begin, I end) {
  print_to_(std::cout, " ", "\n", begin, end);
}
template <typename C>
void println_(const C &cntnr) {
  println_(std::begin(cntnr), std::end(cntnr));
}
template <typename C>
void print_(const C &cntnr) {
  print_(std::begin(cntnr), std::end(cntnr));
}
int _ = (
#ifndef LOCAL
    std::cin.tie(nullptr), std::ios::sync_with_stdio(false),
#endif
    std::cout.precision(10), std::cout.setf(std::ios::fixed));
}  // namespace io
using io::print;
using io::print_;
using io::println;
using io::println_;
template <typename T>
using vec = std::vector<T>;
using vi = vec<int>;
using vvi = vec<vi>;
using pii = std::pair<int, int>;
using ll = long long;
using ld = long double;
using namespace std;
// const int MOD = 1000000007;
using P = std::complex<ld>;
using G = std::vector<P>;
const ld pi = std::acos(-1);
const ld eps = 1e-10;
const ld inf = 1e12;

ld cross(const P &a, const P &b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
ld dot(const P &a, const P &b) {
  return a.real() * b.real() + a.imag() * b.imag();
}

/*
                    CCW

 -- BEHIND -- [a -- ON -- b] --- FRONT --

                    CW
 */
enum CCW_RESULT { CCW = +1, CW = -1, BEHIND = +2, FRONT = -2, ON = 0 };
int ccw(P a, P b, P c) {
  b -= a;
  c -= a;
  if (cross(b, c) > eps) return CCW;    // counter clockwise
  if (cross(b, c) < -eps) return CW;    // clockwise
  if (dot(b, c) < 0) return BEHIND;     // c--a--b on line
  if (norm(b) < norm(c)) return FRONT;  // a--b--c on line
  return ON;
}

namespace std {
bool operator<(const P &a, const P &b) {
  return std::abs(real(a) - real(b)) > eps ? real(a) < real(b)
                                           : imag(a) < imag(b);
}
}  // namespace std

struct L : public std::vector<P> {
  L(const P &a = P(), const P &b = P()) : std::vector<P>(2) {
    begin()[0] = a;
    begin()[1] = b;
  }

  // Ax + By + C = 0
  L(ld A, ld B, ld C) {
    if (std::abs(A) < eps && std::abs(B) < eps) {
      abort();
    } else if (std::abs(A) < eps) {
      *this = L(P(0, -C / B), P(1, -C / B));
    } else if (std::abs(B) < eps) {
      *this = L(P(-C / A, 0), P(-C / A, 1));
    } else {
      *this = L(P(0, -C / B), P(-C / A, 0));
    }
  }
};

struct C {
  P p;
  ld r;
  C(const P &p = 0, ld r = 0) : p(p), r(r) {}
};

template <class iter>
std::pair<P, ld> min_ball(iter left, iter right, int seed = 1333) {
  const int n = right - left;

  assert(n >= 1);
  if (n == 1) {
    return {*left, ld(0)};
  }

  std::mt19937 mt(seed);
  std::shuffle(left, right, mt);
  // std::random_shuffle(left, right); // simple but deprecated

  iter ps = left;
  using circle = std::pair<P, ld>;

  auto make_circle_3 = [](const P &a, const P &b, const P &c) -> circle {
    ld A = std::norm(b - c), B = std::norm(c - a), C = std::norm(a - b),
       S = cross(b - a, c - a);
    P p = (A * (B + C - A) * a + B * (C + A - B) * b + C * (A + B - C) * c) /
          (4 * S * S);
    ld r2 = std::norm(p - a);
    return {p, r2};
  };

  auto make_circle_2 = [](const P &a, const P &b) -> circle {
    P c = (a + b) / (ld)2;
    ld r2 = std::norm(a - c);
    return {c, r2};
  };

  auto in_circle = [](const P &a, const circle &c) -> bool {
    return std::norm(a - c.first) <= c.second + eps;
  };

  circle c = make_circle_2(ps[0], ps[1]);

  // MiniDisc
  for (int i = 2; i < n; ++i) {
    if (!in_circle(ps[i], c)) {
      // MiniDiscWithPoint
      c = make_circle_2(ps[0], ps[i]);
      for (int j = 1; j < i; ++j) {
        if (!in_circle(ps[j], c)) {
          // MiniDiscWith2Points
          c = make_circle_2(ps[i], ps[j]);
          for (int k = 0; k < j; ++k) {
            if (!in_circle(ps[k], c)) {
              c = make_circle_3(ps[i], ps[j], ps[k]);
            }
          }
        }
      }
    }
  }
  return c;
}

int main(void) {
  int N;
  cin >> N;
  vector<P> point(N);
  for (int i = 0; i < N; i++) {
    ld a, b;
    cin >> a >> b;
    point[i].real(a); point[i].imag(b);
  }
  cout << sqrt(min_ball(point.begin(), point.end()).second) << endl;
}

Measured memory_bytes: 256