#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

using i128 = __int128_t;

#define RE real
#define IM imag

using llf = long double;
using lld = int64_t;
using PT = complex<lld>;
using P = PT;
using PF = complex<llf>;

int sgn(int x) { return (x > 0) - (x < 0); }
int sgn(lld x) { return (x > 0) - (x < 0); }
int sgn(i128 x) { return (x > 0) - (x < 0); }

PF toPF(PT p) { return PF{RE(p), IM(p)}; }

lld cross(P a, P b) { return IM(conj(a) * b); }

P rot90(P p) { return P{-IM(p), RE(p)}; }

int ori(P a, P b, P c) {
  return sgn(cross(b - a, c - a));
}

const llf eps = 1e-9;
int sgn(llf x) { return (x > eps) - (x < -eps); }
llf cross(PF a, PF b) { return IM(conj(a) * b); }
llf dot(PF a, PF b) { return RE(conj(a) * b); }
int ori(PF a, PF b, PF c) {
  return sgn(cross(b - a, c - a));
}

int quad(P p) {
  return (IM(p) == 0) ? (RE(p) < 0 ? 3 : 1) : (IM(p) < 0 ? 0 : 2);
}
int argCmp(P a, P b) {
  int qa = quad(a), qb = quad(b);
  if (qa != qb) return sgn(qa - qb);
  return sgn(cross(b, a));
}

template <typename V> llf area(const V &pt) {
  lld ret = 0;
  for (int i = 1; i + 1 < (int)pt.size(); i++)
    ret += cross(pt[i] - pt[0], pt[i + 1] - pt[0]);
  return ret / 2.0;
}

struct Line {
  P st, ed, dir;
  Line(P s, P e) : st(s), ed(e), dir(e - s) {}
};
using LN = const Line &;
PF intersect(LN A, LN B) {
  llf t = cross(B.st - A.st, B.dir) / llf(cross(A.dir, B.dir));
  return toPF(A.st) + toPF(A.dir) * t;
}
bool cov(LN l, LN A, LN B) {
  i128 u = cross(B.st - A.st, B.dir);
  i128 v = cross(A.dir, B.dir);
  i128 x = RE(A.dir) * u + RE(A.st - l.st) * v;
  i128 y = IM(A.dir) * u + IM(A.st - l.st) * v;
  return sgn(x * IM(l.dir) - y * RE(l.dir)) * sgn(v) >= 0;
}
bool operator<(LN a, LN b) {
  if (int c = argCmp(a.dir, b.dir)) return c == -1;
  return ori(a.st, a.ed, b.st) < 0;
}

vector<PF> HPI(vector<Line> &q) {
  sort(q.begin(), q.end());
  int n = (int)q.size(), l = 0, r = -1;
  for (int i = 0; i < n; i++ ) {
    if (i && !argCmp(q[i].dir, q[i - 1].dir)) continue;
    while (l < r && cov(q[i], q[r - 1], q[r])) --r;
    while (l < r && cov(q[i], q[l], q[l + 1])) ++l;
    q[++r] = q[i];
  }
  while (l < r && cov(q[l], q[r - 1], q[r])) --r;
  while (l < r && cov(q[r], q[l], q[l + 1])) ++l;
  n = r - l + 1;
  if (n <= 2 || !argCmp(q[l].dir, q[r].dir)) {
    q.clear();
    return {};
  }
  vector<PF> pt(n);
  for (int i = 0; i < n; i++)
    pt[i] = intersect(q[i + l], q[(i + 1) % n + l]);
  q = vector(q.begin() + l, q.begin() + r + 1);
  return pt;
}

struct Seg {
  PF st, dir;
  Seg(PF s, PF e) : st(s), dir(e - s) {}
  static bool valid(llf p, llf q) {
    if (q < 0) q = -q, p = -p;
    return sgn(0 - p) <= 0 && sgn(p - q) <= 0;
    // return 0 <= p && p <= q;
  }
  vector<PF> ends() const { return {st, st + dir}; }
};

template <typename T> bool isInter(T A, PF p) {
  if (abs(A.dir) < eps) return abs(p - A.st) < eps;
  return sgn(cross(p - A.st, A.dir)) == 0 && T::valid(dot(p - A.st, A.dir), norm(A.dir));
}

template <typename U, typename V>
bool isInter(U A, V B) {
  if (sgn(cross(A.dir, B.dir)) == 0) {
    bool res = false;
    for (PF p : A.ends()) res |= isInter(B, p);
    for (PF p : B.ends()) res |= isInter(A, p);
    return res;
  }
  PF D = B.st - A.st;
  llf C = cross(A.dir, B.dir);
  return U::valid(cross(D, B.dir), C) && V::valid(cross(D, A.dir), C);
}

bool PIP(const vector<PF> &p, PF z, bool strict = true) {
  int cnt = 0, n = (int)p.size();
  for (int i = 0; i < n; i++) {
    PF A = p[i], B = p[(i + 1) % n];
    if (isInter(Seg(A, B), z)) return !strict;
    auto zy = IM(z), Ay = IM(A), By = IM(B);
    cnt ^= ((zy < Ay) - (zy < By)) * ori(z, A, B) > 0;
  }
  return cnt;
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);

  int n;
  cin >> n;

  vector<P> p(n);
  vector<PF> pf(n);

  vector<Seg> ps;
  vector<Line> pe;

  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    p[i] = P(x, y);

    pf[i] = toPF(p[i]);
  }

  for (int i = 0; i < n; i++)
    ps.emplace_back(pf[i], pf[(i + 1) % n]);
  for (int i = 0; i < n; i++)
    pe.emplace_back(p[i] * lld(2), p[(i + 1) % n] * lld(2));

  vector<Line> frame;
  {
    const int C = 20005;
    P q[4] = {P(-C, -C), P(C, -C), P(C, C), P(-C, C)};
    frame = {Line(q[0], q[1]), Line(q[1], q[2]), Line(q[2], q[3]), Line(q[3], q[0])};
  }

  llf ans = 0;

  for (int i = 0; i < n; i++) {
    vector<Line> ls = frame;
    for (int j = 0; j < n; j++) if (j != i) {
      P m = p[i] + p[j], d = rot90(p[j] - p[i]);
      assert(norm(d) != 0);
      ls.emplace_back(m, m + d);
    }

    auto hull = HPI(ls);
    if (hull.empty())
      continue;

    for (PF &z : hull)
      z /= llf(2);

    for (size_t j = 0; j < hull.size(); j++) {
      if (PIP(pf, hull[j], false)) {
        ans = max(ans, abs(hull[j] - pf[i]));
      }
    }

    for (size_t j = 0; j < pf.size(); j++) {
      if (PIP(hull, pf[j], false)) {
        ans = max(ans, abs(pf[j] - pf[i]));
      }
    }

    vector<Seg> seg;
    for (size_t j = 0; j < hull.size(); j++)
      seg.emplace_back(hull[(j + hull.size() - 1) % hull.size()], hull[j]);

    for (size_t j = 0; j < seg.size(); j++) {
      for (size_t k = 0; k < ps.size(); k++) {
        if (isInter(seg[j], ps[k])) {
          debug(seg[j].dir, ps[k].dir);
          debug(ls[j].dir, pe[k].dir);
          PF z = intersect(ls[j], pe[k]);
          z /= llf(2);
          ans = max(ans, abs(z - pf[i]));
        }
      }
    }
  }

  cout << fixed << setprecision(20);
  cout << ans << '\n';

  return 0;
}