#include "bits/stdc++.h"
using namespace std;
using ll = unsigned long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)

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

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

const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;

// -------------------------------------------------------

using FloatType = long double;
using P = complex<FloatType>;

#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))

FloatType dot(P a, P b) { return a.real() * b.real() + a.imag() * b.imag(); }

FloatType cross(P a, P b) { return a.real() * b.imag() - a.imag() * b.real(); }

// 2直線の直行判定
bool is_orthogonal(P a1, P a2, P b1, P b2) {
  return EQ(dot(a1 - a2, b1 - b2), 0.0);
}

// 2直線の平行判定
bool is_parallel(P a1, P a2, P b1, P b2) {
  return EQ(cross(a1 - a2, b1 - b2), 0.0);
}

// 点cが直線a-b上にあるか
bool is_point_on_line(P a, P b, P c) { return EQ(cross(b - a, c - a), 0.0); }

// 点cが線分a-b上にあるか
bool is_point_on_line_segment(P a, P b, P c) {
  return (abs(c - a) + abs(c - b) < abs(b - a) + EPS);
}

// 点a,bを通る直線と点cとの距離
FloatType distance_l_p(P a, P b, P c) {
  return abs(cross(b - a, c - a)) / abs(b - a);
}

// 点a,bを通る線分と点cとの距離
FloatType distance_ls_p(P a, P b, P c) {
  if (dot(b - a, c - a) < EPS) return abs(c - a);
  if (dot(a - b, c - b) < EPS) return abs(c - b);
  return distance_l_p(a, b, c);
}

// a1,a2を端点とする線分とb1,b2を端点とする線分の交差判定
FloatType is_intersected_ls(P a1, P a2, P b1, P b2) {
  return (cross(a2 - a1, b1 - a1) * cross(a2 - a1, b2 - a1) < EPS) &&
         (cross(b2 - b1, a1 - b1) * cross(b2 - b1, a2 - b1) < EPS);
}

// a1,a2を端点とする線分とb1,b2を端点とする線分の交点計算
P intersection_ls(P a1, P a2, P b1, P b2) {
  P b = b2 - b1;
  FloatType d1 = abs(cross(b, a1 - b1));
  FloatType d2 = abs(cross(b, a2 - b1));
  FloatType t = d1 / (d1 + d2);

  return a1 + (a2 - a1) * t;
}

// a1,a2を通る直線とb1,b2を通る直線の交差判定
bool is_intersected_l(P a1, P a2, P b1, P b2) {
  return !EQ(cross(a1 - a2, b1 - b2), 0.0);
}

// a1,a2を通る直線とb1,b2を通る直線の交点計算
P intersection_l(P a1, P a2, P b1, P b2) {
  P a = a2 - a1;
  P b = b2 - b1;
  return a1 + a * cross(b, b1 - a1) / cross(b, a);
}

ll N;
ll x[100], y[100];

bool is_ok(long double r) {
  rep(i, 0, N - 1) {
    rep(j, i + 1, N) {
      P p1 = P(x[i], y[i]);
      P p2 = P(x[j], y[j]);
      P p1p2 = p2 - p1;

      if (abs(p1p2) > 2.0L * r + EPS) return false;

      P p1p2u = p1p2 / abs(p1p2);
      P p1p2un1 = p1p2u * P(0, 1);
      P p1p2un2 = p1p2u * P(0, -1);

      P p1p2half = p1p2 / 2.0L;
      long double h = sqrt(r * r - abs(p1p2half) * abs(p1p2half));
      P midp = p1 + p1p2 / 2.0L;
      P isect1 = midp + p1p2un1 * h;
      P isect2 = midp + p1p2un2 * h;

      // cout << isect1.real() << " " << isect1.imag() << endl;

      bool ok1 = true;
      rep(k, 0, N) {
        if (k == i || k == j) continue;

        P cp = P(x[k], y[k]);
        if (abs(isect1 - cp) > r + EPS) {
          ok1 = false;
          break;
        }
      }

      bool ok2 = true;
      rep(k, 0, N) {
        if (k == i || k == j) continue;

        P cp = P(x[k], y[k]);
        if (abs(isect2 - cp) > r + EPS) {
          ok2 = false;
          break;
        }
      }

      // cout << "ok1" << ok1 << endl;
      // cout << "ok2" << ok2 << endl;

      if (ok1 || ok2) {
        return true;
      }
    }
  }

  return false;
}

int main() {
  cin >> N;
  rep(i, 0, N) { cin >> x[i] >> y[i]; }

  long double ub = 1000.0L;
  long double lb = EPS;

  rep(loopcnt, 0, 50) {
    long double r = (ub + lb) / 2.0L;
    if (is_ok(r)) {
      ub = r;
    } else {
      lb = r;
    }
  }

  cout << setprecision(20) << fixed << ub << endl;
}


Measured memory_bytes: 3884