#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;

typedef pair<ll, ll> P;

#define bit(n) (1LL << (n))

//#define int long long

#define all(v) v.begin(), v.end()

#define rep(i, n) for (ll i = 0; i < n; i++)
#define REP(i, n) for (ll i = 1; i < n; i++)

#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORm(i, m) for (auto i = m.begin(); i != m.end(); i++)

template <class T>
inline void chmax(T& a, T b) {
  a = std::max(a, b);
}
template <class T>
inline void chmin(T& a, T b) {
  a = std::min(a, b);
}

#define mod (ll)(1e9 + 7)
#define INF LLONG_MAX

template <ll ModVal>
struct ModInt {
  ll x;

  ModInt(ll _x = 0) : x((_x % ModVal + ModVal) % ModVal) {
  }

  ModInt operator-() const {
    return ModInt(-x);
  }
  ModInt& operator+=(const ModInt a) {
    x += a.x;
    if (x >= ModVal)
      x -= ModVal;
    return *this;
  }
  ModInt& operator-=(const ModInt a) {
    x = x + ModVal - a.x;
    if (x >= ModVal)
      x -= ModVal;
    return *this;
  }
  ModInt& operator*=(const ModInt a) {
    x *= a.x;
    x %= ModVal;
    return *this;
  }

  ll ext_gcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
      x = 1;
      y = 0;
      return a;
    }
    ll tmp = a / b;
    ll d = ext_gcd(b, a - b * tmp, y, x);
    y -= tmp * x;
    return d;
  }

  // 逆元
  ModInt inv(const ModInt a) {
    ll u, v;
    ext_gcd(a.x, ModVal, u, v);
    return ModInt(u);
  }

  ModInt& operator/=(const ModInt a) {
    return (*this) *= inv(a);
  }

  ModInt operator+(const ModInt a) const {
    ModInt retval(*this);
    return retval += a;
  }
  ModInt operator-(const ModInt a) const {
    ModInt retval(*this);
    return retval -= a;
  }
  ModInt operator*(const ModInt a) const {
    ModInt retval(*this);
    return retval *= a;
  }
  ModInt operator/(const ModInt a) const {
    ModInt retval(*this);
    return retval /= a;
  }

  ModInt pow(ll n) {
    ModInt ans(1);
    while (n) {
      if (n & 1)
        ans = ans * x;
      *this = (*this) * (*this);
      n = n >> 1;
    }
    return ans;
  }

  constexpr const ll& value() {
    return this->x;
  }
};

template <ll ModVal>
ostream& operator<<(ostream& os, const ModInt<ModVal>& a) {
  os << a.x;
  return os;
}

using mint = ModInt<mod>;

template <typename T>
class Combination {
 public:
  Combination(ll _max_n) : max_n(_max_n), factional(max_n + 1), inv(max_n + 1) {
    factional[0] = 1;
    inv[0] = 1;
    for (ll i = 0; i < max_n; i++) {
      factional[i + 1] = factional[i] * (i + 1); // n!(mod M)
      inv[i + 1] = inv[i] / (i + 1);             // k!^(M-2) (mod M)
    }
  }

  // nCk
  T choose(ll n, ll k) {
    if (n == 0 && k == 0)
      return 1;
    if (n < k || n < 0)
      return 0;
    T tmp = inv[n - k] * inv[k];
    return tmp * factional[n];
  }

 private:
  const ll max_n;
  std::vector<T> factional;
  std::vector<T> inv;
};

using Comb = Combination<mint>;

const ld eps = 1.0e-15;

ll n;
vector<pair<ld, ld>> p;

ld getDist(const pair<ld, ld>& a, const pair<ld, ld>& b) {
  ld ans = pow(a.first - b.first, 2) + pow(a.second - b.second, 2);
  ans = sqrt(ans);
  return ans;
}

vector<pair<ld, ld>> getCrossPoints(pair<ld, ld> a, pair<ld, ld> b, ld r) {
  vector<pair<ld, ld>> ans;
  ld d = getDist(a, b);
  // 交点なし
  if (d > 2 * r) {
    return ans;
  } else {
    ld h = pow(r, 2) - pow(d / 2, 2);
    h = sqrt(h);

    pair<ld, ld> center = make_pair((a.first + b.first) / 2, (a.second + b.second) / 2);

    // 線分abに対する単位法線ベクトル
    pair<ld, ld> e = make_pair((b.second - a.second) / d, -(b.first - a.first) / d);

    pair<ld, ld> u = center;
    u.first += e.first * h;
    u.second += e.second * h;
    ans.push_back(u);

    u = center;
    u.first -= e.first * h;
    u.second -= e.second * h;
    ans.push_back(u);
  }
  return ans;
}

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(20);

  ll n;
  cin >> n;
  p = vector<pair<ld, ld>>(n);

  rep(i, n) {
    cin >> p[i].first >> p[i].second;
  }

  ld left, right;
  left = 0;
  right = 5000;

  while (right - left > 0.000000001L) {
    // 円の半径
    ld r = (left + right) / 2;

    rep(i, n) {
      for (int j = i + 1; j < n; j++) {
        auto cp = getCrossPoints(p[i], p[j], r);
        // そもそも円同士が接しない
        if (cp.size() == 0) {
          left = r;
          goto next_step;
        }
        FORm(it, cp) {
          bool is_all_points_inside = true;
          rep(k, n) {
            auto d = getDist(*it, p[k]);
            if (d - eps > r) {
              is_all_points_inside = false;
              break;
            }
          }
          if (is_all_points_inside) {
            // すべての点が半径r内に入った
            right = r;
            goto next_step;
          }
        }
      }
    }
    left = r;
  next_step:;
  }

  cout << (left + right) / 2 << endl;

  return 0;
}


Measured memory_bytes: 256