#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;

#ifdef local
#define safe std::cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(args...) qqbx(#args, args)
#define orange(args...) danb(#args, args)
using std::cerr;
template <typename ...T> void qqbx(const char *s, T ...args) {
  int cnt = sizeof...(T);
  ((cerr << "\e[1;32m(" << s << ") = ("), ..., (cerr << args << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I> void danb(const char *s, I L, I R) {
  cerr << "\e[1;32m[ " << s << " ] = [ ";
  for (int f = 0; L != R; ++L) cerr << (f++ ? ", " : "") << *L;
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif // local
#define all(v) begin(v),end(v)

#define IM imag
#define RE real

using lld = int64_t;
using llf = long double;

using P = std::complex<lld>;

int sgn(lld x) {
  return (x > 0) - (x < 0);
}
lld dot(P a, P b) { return RE(conj(a) * b); }
lld cross(P a, P b) { return IM(conj(a) * b); }
int ori(P a, P b, P c) {
  return sgn(cross(b - a, c - a));
}

bool cmpxy(P a, P b) {
  return make_pair(RE(a), IM(a)) < make_pair(RE(b), IM(b));
}

// from NaCl, counterclockwise, be careful of n<=2
vector<P> convex_hull(vector<P> v) {
  if (v.empty()) return {};
  sort(all(v), cmpxy); // by X then Y
  if (v[0] == v.back()) return {v[0]};
  int t = 0, s = 1; vector<P> h(v.size() + 1);
  for (int _ = 2; _--; s = t--, reverse(all(v)))
    for (P p : v) {
      while (t>s && ori(p, h[t-1], h[t-2]) >= 0) t--;
      h[t++] = p;
    }
  return h.resize(t), h;
}

P find_extreme(const vector<P> &h, P e) {
  const auto gao = [&, N = int(h.size())](int s) {
    const auto lt = [&](int x, int y) {
      return sgn(cross(e, h[x % N] - h[y % N])) == s; };
    int l = 0, r = N; bool up = lt(0, 1);
    while (r - l > 1) {
      int m = (l + r) / 2;
      if (lt(m, 0) ? up : !lt(m, m+1)) r = m;
      else l = m;
    }
    return (lt(l, r) ? r : l) % N;
  }; // test @ codeforces.com/gym/101201/problem/E
  // for (P z : h)
  //   if (cross(e, z) > cross(e, res))
  //     res = z;
  return h[gao(-1)];
}

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

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


  auto h = convex_hull(p);
  const int k = (int)h.size();

  const auto contain = [&](int x, P z) {
    P a = h[(x+k-1)%k];
    P b = h[x];
    P c = h[(x+1)%k];
    assert (ori(a, b, c) > 0);
    if (a == z || b == z || c == z)
      return false;
    return ori(a, b, z) >= 0 && ori(b, c, z) >= 0 && ori(c, a, z) >= 0;
  };

  vector<vector<P>> pt(k), with_adj(k);

  for (int i = 0; i < n; i++) {
    int l = 1, r = k;
    while (r - l > 1) {
      int m = (l + r) / 2;
      if (cross(p[i] - h[0], h[m] - h[0]) <= 0) {
        l = m;
      } else {
        r = m;
      }
    }

    {
      P a = h[0];
      P b = h[l];
      P c = h[(l+1)%k];
      assert (ori(a, b, c) >= 0);
      assert ( ori(a, b, p[i]) >= 0 && ori(b, c, p[i]) >= 0 && ori(c, a, p[i]) >= 0 );
    }

    for (int j : {0, l, (l+1)%k}) {
      if (contain(j, p[i])) {
        pt[j].push_back(p[i]);
      }
    }
  }

  for (int i = 0; i < k; i++) {
    pt[i].push_back(h[(i + 1) % k]);
    pt[i].push_back(h[(i + k - 1) % k]);
    pt[i] = convex_hull(pt[i]);
  }

  llf ans = 1e18;
  {
    int pos = 1;
    for (int i = 0; i < k; i++) {
      P e = h[(i + 1) % k] - h[i];
      while (cross(e, h[(pos + 1) % k] - h[i]) > cross(e, h[pos] - h[i]))
        pos = (pos + 1) % k;
      P x = find_extreme(pt[pos], e);
      ans = min(ans, cross(e, x - h[i]) / sqrtl(norm(e)));
    }
  }

  for (int t = 0; t < k; t++) {
    const auto &q = pt[t];
    const int z = (int)q.size();
    assert (z >= 2);
    // int pos = 1;
    for (int i = 0; i < z; i++) {
      P e = q[(i + 1) % z] - q[i];
      // while (cross(e, q[(pos + 1) % z] - q[i]) > cross(e, q[pos] - q[i]))
      //   pos = (pos + 1) % z;
      P x = find_extreme(h, e);
      P y = find_extreme(h, -e);
      if (y == h[t])
        ans = min(ans, cross(e, x - q[i]) / sqrtl(norm(e)));
    }
  }

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

}