#include "bits/stdc++.h"

#define all(x)   x.begin(), x.end()
#define NL       std::cout << '\n'

using lnt = long long;

const int inf = 0x3f3f3f3f;
const lnt linf = 1ll << 62;


using db = double; const db eps = 1e-4;
int sgn(db x) { return (x < -eps ? -1 : x > eps); }

struct Pt { db x, y; };
std::istream& operator>>(std::istream& is, Pt &p) {
  int x, y; std::cin >> x >> y;
  p.x = x; p.y = y; return is;
}

Pt operator-(Pt a, Pt b) { return { a.x - b.x, a.y - b.y }; }
Pt operator+(Pt a, Pt b) { return { a.x + b.x, a.y + b.y }; }
Pt operator*(Pt a, db x) { return { a.x * x, a.y * x }; }
Pt operator/(Pt a, db x) { return { a.x / x, a.y / x }; }
db dot(Pt a, Pt b) { return a.x * b.x + a.y * b.y; }
db det(Pt a, Pt b) { return a.x * b.y - a.y * b.x; }
bool operator==(Pt a, Pt b) { return !sgn(dot(a-b, a-b)); }
bool operator!=(Pt a, Pt b) { return sgn(dot(a-b, a-b)); }
bool operator<(Pt a, Pt b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
db dis2(Pt a, Pt b) { return dot(a-b, a-b); }
db dis(Pt a, Pt b) { return std::sqrt((long double)dis2(a, b)); }
int side(Pt a, Pt b, Pt x) { return sgn(det(b-a, x-a)); }
Pt rot90(Pt a) { return {-a.y, a.x}; }

struct Line { Pt s, t; };

Pt intersect(Line a, Line b) {
  db v = det(a.t - a.s, b.s - a.s);
  db u = det(a.t - a.s, b.t - a.s);
  return (b.s * u - b.t * v) / (u - v);
}

bool para(Line a, Line b) {
  return !sgn(det(a.t - a.s, b.t - b.s));
}

struct Seg { Pt s, t; };

Line bisector(Seg v) {
  Pt a = v.s + ((v.t - v.s) / 2);
  Pt b = a + rot90(v.t - v.s);
  return {a, b};
}

bool ptonseg(Pt x, Seg v) {
  return sgn(det(v.s - x, v.t - x)) == 0
      && sgn(dot(v.s - x, v.t - x)) <= 0;
}

std::vector<Pt> polyCut(std::vector<Pt> &v, Line l) {
  std::vector<Pt> ret; ret.reserve(v.size());
  for (int j = 0, i = v.size() - 1, ok = 0; j < v.size(); i = j++) {
    bool s = side(l.s, l.t, v[j]) > 0;
    if (s != side(l.s, l.t, v[i]) > 0) {
      ret.emplace_back(intersect(l, {v[i], v[j]}));
    }
    if (s) {
      ret.emplace_back(v[j]);
    }
  }
  return ret;
}


std::vector<std::vector<Pt>> voronoi(const std::vector<Pt> &p) {
  auto pp = p;
  std::shuffle(all(pp), std::mt19937(233333333));
  const db W = 3e4;
  std::vector<std::vector<Pt>> ret(p.size(),
    {{-W, -W}, {W, -W}, {W, W}, {-W, W}});
  for (int i = 0; i < p.size(); ++i) {
    for (auto u : pp) {
      if (u == p[i]) { continue; }
      ret[i] = polyCut(ret[i], bisector({p[i], u}));
    }
  }
  return ret;
}

bool inPoly(std::vector<Pt> &v, Pt p) {
  int cnt = 0;
  for (int i = v.size() - 1, j = 0; j < v.size(); i = j++) {
    if (ptonseg(p, {v[i], v[j]})) { return true; }
    int x = sgn(det(p - v[i], v[j] - v[i]));
    int y = sgn(v[i].y - p.y);
    int z = sgn(v[j].y - p.y);
    if (x > 0 && y <= 0 && z > 0) { ++cnt; }
    if (x < 0 && z <= 0 && y > 0) { --cnt; }
  }
  return cnt != 0;
}

bool seginter(Seg a, Seg b) {
  if (sgn(det(b.s-a.s, a.t-a.s)) * sgn(det(b.t-a.s, a.t-a.s)) == -1
   && sgn(det(a.s-b.s, b.t-b.s)) * sgn(det(a.t-b.s, b.t-b.s)) == -1) {
    return true;
  }
  return false;
}

int main() {
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int n; std::cin >> n;
  std::vector<Pt> v(n);
  for (int i = 0; i < n; ++i) {
    std::cin >> v[i];
  }


  db ret = 0;
  auto vg = voronoi(v);
  for (int i = 0; i < n; ++i) {
    const auto &vgp = vg[i];
    for (int a = vgp.size() - 1, b = 0; b < vgp.size(); a = b++) {
      if (inPoly(v, vgp[a])) {
        ret = std::max(dis2(v[i], vgp[a]), ret);
      }
      for (int c = v.size() - 1, d = 0; d < v.size(); c = d++) {
        if (para({vgp[a], vgp[b]}, {v[c], v[d]})) { continue; }
        if (seginter({vgp[a], vgp[b]}, {v[c], v[d]})) {
          Pt inter = intersect({vgp[a], vgp[b]}, {v[c], v[d]});
          db mi = linf;
          for (auto b : v) {
            mi = std::min(mi, dis2(inter, b));
          }
          ret = std::max(mi, ret);
        }
      }
    }
  }
  std::cout << std::fixed << std::setprecision(10);
  std::cout << std::sqrt(ret);
  return 0;
}