// https://atcoder.jp/contests/abc151/tasks/abc151_f

#include "algorithm"
#include "bitset"
#include "cmath"
#include "functional"
#include "iomanip"
#include "iostream"
#include "map"
#include "numeric"
#include "queue"
#include "set"
#include "string"
#include "vector"
#define rep(i, to) for (ll i = 0; i < (to); ++i)
#define rep1(i, to) for (ll i = 1; i <= (to); ++i)
#define repf(i, from, to) for (ll i = from; i < (to); ++i)
#define repr(i, from) for (ll i = from - 1; i >= 0; --i)
#define all(vec) vec.begin(), vec.end()
#define unless(cond) if (!(cond))
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef long double lld;
template <typename T>
using V = vector<T>;
using VL = V<ll>;
using VVL = V<VL>;
template <typename T, typename U>
using P = pair<T, U>;
using PL = P<ll, ll>;
using VPL = V<PL>;
template <typename T>
inline bool chmax(T& a, T b);
template <typename T>
inline bool chmin(T& a, T b);
void print_ints(vector<ll> v);
template <typename T>
void drop(T a);

const ll INF = 1e18;

lld dist2(P<lld, lld> a, P<lld, lld> b) {
  return pow(a.fi - b.fi, 2) + pow(a.se - b.se, 2);
}

lld dist(P<lld, lld> a, P<lld, lld> b) {
  lld res = sqrt(dist2(a, b));
  return res;
}

P<P<lld, lld>, lld> circle(const P<lld, lld> a, const P<lld, lld> b,
                           const P<lld, lld> c) {
  lld ox = (min(min(a.fi, b.fi), c.fi) + max(min(a.fi, b.fi), c.fi)) / 2;
  lld oy = (min(min(a.se, b.se), c.se) + max(min(a.se, b.se), c.se)) / 2;
  lld ax = a.fi - ox, ay = a.se - oy;
  lld bx = b.fi - ox, by = b.se - oy;
  lld cx = c.fi - ox, cy = c.se - oy;
  lld d = (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) * 2;
  if (d == 0) {
    return {P<lld, lld>{-1, -1}, -1};
  }

  lld x = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) +
           (cx * cx + cy * cy) * (ay - by)) /
          d;
  lld y = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) +
           (cx * cx + cy * cy) * (bx - ax)) /
          d;
  P<lld, lld> p = {ox + x, oy + y};
  lld r = max(max(dist(p, a), dist(p, b)), dist(p, c));
  return {p, r};
}

void solve() {
  ll N;
  cin >> N;

  V<P<lld, lld>> ps(N);

  rep(i, N) {
    lld x, y;
    cin >> x >> y;
    ps[i] = {x, y};
  }

  auto is_ok = [&](P<lld, lld> c, lld r) -> bool {
    rep(i, N) {
      PL p = ps[i];

      unless(pow(c.fi - p.fi, 2) + pow(c.se - p.se, 2) <= r * r + 1e-8) {
        return false;
      }
    }

    return true;
  };

  // P<lld, lld> res_center;
  lld res = 1e18;

  // 2 点を直径に持つ
  rep(j, N) rep(i, j) {
    P<lld, lld> cent = {(ps[i].fi + ps[j].fi) / 2, (ps[i].se + ps[j].se) / 2};
    lld rad = sqrt(pow(cent.fi - ps[i].fi, 2) + pow(cent.se - ps[i].se, 2));

    if (rad < res && is_ok(cent, rad)) {
      res = rad;
    }
  }

  // 3 点を通るか
  rep(k, N) rep(j, k) rep(i, j) {
    auto cc = circle(ps[i], ps[j], ps[k]);

    auto cen = cc.fi;
    auto rad = cc.se;
    if (rad == -1) continue;

    if (rad < res && is_ok(cen, rad)) {
      res = rad;
    }
  }

  cout << fixed << setprecision(15) << res << endl;
}

struct exit_exception : public std::exception {
  const char* what() const throw() { return "Exited"; }
};

#ifndef TEST
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  try {
    solve();
  } catch (exit_exception& e) {
  }

  return 0;
}
#endif

template <typename T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}

template <typename T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

void print_ints(vector<ll> v) {
  rep(i, v.size()) {
    if (i > 0) {
      cout << " ";
    }

    cout << v[i];
  }

  cout << endl;
}

template <typename T>
void drop(T res) {
  cout << res << endl;
  throw exit_exception();
}


Measured memory_bytes: 256