#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
  c b, e;
};
template <class c>
rge<c> range(c i, c j) {
  return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
  template <class c>
  debug& operator<<(const c&) {
    return *this;
  }
};
using namespace std;
template <typename T>
T K(T a) {
  return a * a;
}
typedef long double ll;
const long double eps = 1e-12;
#pragma GCC diagnostic ignored "-Wnarrowing"
struct P {
  ll x, y;
  void read() { cin >> x >> y; }
  P operator-(const P& he) const { return P{x - he.x, y - he.y}; }
  P operator+(const P& he) const { return P{x + he.x, y + he.y}; }
  ll operator*(const P& he) const { return x * he.y - y * he.x; }
  P operator*(long double mul) const { return P{x * mul, y * mul}; }
  P operator/(long double mul) const { return P{x / mul, y / mul}; }
  long double len() const { return sqrt(x * x + y * y); }
  ll dot(P b) { return x * b.x + y * b.y; }
  long double len() { return sqrt(K(1LL * (x)) + K(1LL * (y))); }
  P scaleTo(long double to) { return *this * (to / len()); }
  long double dist(P& b) { return (*this - b).len(); }
  P rotate90() { return P{-y, x}; }
  long double angle() { return atan2(y, x); }
  P rotate(long double ang) {
    long double c = cos(ang), s = sin(ang);
    return P{x * c - y * s, x * s + y * c};
  }
  bool operator<(P he) { return make_pair(x, y) < make_pair(he.x, he.y); }
  bool below(P a, P b) { return (b - a) * (*this - a) <= 0; }
  P apol_in(P b, long double ratio) {
    return (*this + b * ratio) / (1 + ratio);
  }
  P apol_out(P b, long double ratio) {
    return (*this - b * ratio) / (1 - ratio);
  }
};
debug& operator<<(debug& dd, P p) {
  dd << "(" << p.x << ", " << p.y << ")";
  return dd;
}
struct L2 {
  P one, two;
  P dir() { return two - one; }
  P normal() { return dir().rotate90(); }
  long double dist(P he) {
    return abs((he - one) * (he - two)) / one.dist(two);
  }
  long double segDist(P he) {
    if ((he - two) * normal() < 0 && normal() * (he - one) < 0) return dist(he);
    return min(one.dist(he), two.dist(he));
  }
  P inter(L2 he) {
    P A = dir(), B = he.dir();
    ll den = A * B;
    assert(abs(den) > eps);
    return (A * (he.one * he.two) - B * (one * two)) * (1.0 / den);
  }
  P project(P he) {
    P unit_normal = normal().scaleTo(1);
    return he + unit_normal * unit_normal.dot(one - he);
  }
  P reflect(P he) { return project(he) * 2 - he; }
};
L2 toL2(ll a, ll b, ll c) {
  P first;
  if (abs(b) > eps)
    first = P{0, (long double)-c / b};
  else if (abs(a) > eps)
    first = P{(long double)-c / a, 0};
  else
    assert(false);
  return L2{first, first + P{b, -a}};
}
ll det(ll t[3][3]) {
  ll s = 0;
  for (int i = 0; i < 3; ++i)
    for (int j = i + 1, mul = 1; j != i + 3; ++j, mul -= 2)
      s += t[0][i] * t[1][j % 3] * t[2][3 - i - j % 3] * mul;
  return s;
}
struct L3 {
  ll a, b, c;
  L3 fix() {
    assert(abs(b) > eps || abs(a) > eps);
    ll g = (b > eps || (abs(b) < eps && a > eps)) ? 1 : -1;
    return L3{a / g, b / g, c / g};
  }
  long double dist(P he) {
    return abs(a * he.x + b * he.y + c) / sqrt(K(1LL * (a)) + K(1LL * (b)));
  }
  P dir() { return P{b, -a}; }
  P normal() { return P{a, b}; }
  P project(P he) {
    long double den = K(1LL * (a)) + K(1LL * (b));
    return P{(b * (b * he.x - a * he.y) - a * c) / den,
             (a * (a * he.y - b * he.x) - b * c) / den};
  }
  P reflect(P he) { return project(he) * 2 - he; }
  P inter(L3 he) {
    ll den = (a * he.b - b * he.a);
    assert(abs(den) > 1e-14);
    return P{(b * he.c - c * he.b), (c * he.a - a * he.c)} * (1.0 / den);
  }
  bool operator<(L3 he) {
    if (abs(a * he.b - b * he.a) < eps) return b * he.c < c * he.b;
    return a * he.b < b * he.a;
  }
  bool below(L3 A, L3 C) {
    ll t[3][3] = {{A.a, A.b, A.c}, {a, b, c}, {C.a, C.b, C.c}};
    return det(t) <= 0;
  }
};
L3 toL3(P one, P two) {
  ll a = two.y - one.y;
  ll b = one.x - two.x;
  return L3{a, b, -(a * one.x + b * one.y)}.fix();
}
struct Circle {
  P o;
  long double r;
  vector<P> tangency(P he) {
    long double d = o.dist(he);
    if (abs(d - r) < eps) return vector<P>{he};
    if (d < r) return vector<P>{};
    long double alpha = asin(r / d);
    P vec = (o - he) * sqrt(1 - K(1LL * (r / d)));
    return vector<P>{he + vec.rotate(alpha), he + vec.rotate(-alpha)};
  }
  vector<P> inter(L3 he) {
    P prim = he.project(o);
    long double d = prim.dist(o);
    if (d >= r + eps) return vector<P>{};
    if (abs(d - r) <= eps) return vector<P>{prim};
    P vec = he.dir().scaleTo(sqrt(K(1LL * (r)) - K(1LL * (d))));
    return vector<P>{prim + vec, prim - vec};
  }
  vector<P> inter(Circle he) {
    return inter(L3{2 * (o.x - he.o.x), 2 * (o.y - he.o.y),
                    K(1LL * (r)) - K(1LL * (he.r)) - K(1LL * (o.x)) -
                        K(1LL * (o.y)) + K(1LL * (he.o.x)) +
                        K(1LL * (he.o.y))});
  }
  vector<L2> tangency(Circle he) {
    vector<L2> ret;
    long double ratio = r / he.r;
    auto considerPoint = [&](P p) {
      vector<P> one = tangency(p), two = he.tangency(p);
      for (int i = 0; i < (int)min(one.size(), two.size()); ++i)
        ret.push_back(L2{one[i], two[i]});
    };
    if (abs(r - he.r < 1e-9)) {
      P dir = (he.o - o).rotate90().scaleTo(r);
      for (int tmp : {1, -1})
        ret.push_back(L2{o + dir * tmp, he.o + dir * tmp});
    } else
      considerPoint(o.apol_out(he.o, ratio));
    considerPoint(o.apol_in(he.o, ratio));
    return ret;
  }
};
Circle apollonius(P a, P b, long double ratio) {
  assert(ratio >= 0);
  assert(abs(ratio - 1) > 1e-14);
  P in = a.apol_in(b, ratio), out = a.apol_out(b, ratio);
  return Circle{(in + out) / 2, in.dist(out) / 2};
}
int n;
vector<P> points;
vector<L2> segments;
const double DOUBLE_INF = 1e15 + 5;
double answer_for_both(P me, P other_guard, int _my_seg, int _his_seg) {
  vector<pair<P, int>> guards;
  guards.emplace_back(me, _my_seg);
  guards.emplace_back(other_guard, _his_seg);
  double max_ratio_needed = -1;
  for (int seg = 0; seg < n; ++seg) {
    if (seg == _my_seg) {
      continue;
    }
    double their_min = DOUBLE_INF;
    for (pair<P, int> pp : guards) {
      P he = pp.first;
      int his_seg = pp.second;
      debug() << " ["
              << "me"
                 ": "
              << (me)
              << "] "
                 " ["
              << "he"
                 ": "
              << (he)
              << "] "
                 " ["
              << "_my_seg"
                 ": "
              << (_my_seg)
              << "] "
                 " ["
              << "his_seg"
                 ": "
              << (his_seg)
              << "] "
                 " ["
              << "seg"
                 ": "
              << (seg) << "] ";
      if (his_seg < seg) {
        double dist_already = 0;
        for (int i = his_seg; i < seg; ++i) {
          dist_already += he.dist(segments[i].two);
          he = segments[i].two;
        }
        P A = segments[seg].one;
        P B = segments[seg].two;
        assert(A.dist(he) < 1e-9);
        he = he - (B - A) * (dist_already / A.dist(B));
      } else if (his_seg > seg) {
        double dist_already = 0;
        for (int i = his_seg; i > seg; --i) {
          dist_already += he.dist(segments[i].one);
          he = segments[i].one;
        }
        P A = segments[seg].two;
        P B = segments[seg].one;
        assert(A.dist(he) < 1e-9);
        he = he - (B - A) * (dist_already / A.dist(B));
      }
      debug() << " ["
              << "he"
                 ": "
              << (he) << "] ";
      if (me.dist(he) < 1e-9) {
        their_min = 1;
        break;
      }
      double low = 1 + 0.9 * 1e-6;
      double high = 12345;
      for (int rep = 0; rep < 40; ++rep) {
        double ratio = (low + high) / 2;
        Circle c = apollonius(he, me, ratio);
        if (segments[seg].segDist(c.o) < c.r) {
          low = ratio;
        } else {
          high = ratio;
        }
      }
      their_min = min(their_min, (low + high) / 2);
    }
    max_ratio_needed = max(max_ratio_needed, their_min);
  }
  return max_ratio_needed;
}
double answer_for_my_position(P me, int my_seg, bool flag = false) {
  double his_min_answer = DOUBLE_INF;
  for (int his_seg = 0; his_seg < n; ++his_seg) {
    double low = 0, high = 1;
    his_min_answer =
        min({his_min_answer,
             answer_for_both(me, segments[his_seg].one, my_seg, his_seg)});
    his_min_answer =
        min({his_min_answer,
             answer_for_both(me, segments[his_seg].two, my_seg, his_seg)});
    for (int rep = 0; rep < 40; ++rep) {
      double mid1 = (3 * low + 2 * high) / 5;
      double mid2 = (2 * low + 3 * high) / 5;
      P he1 = points[his_seg] + (points[his_seg + 1] - points[his_seg]) * mid1;
      P he2 = points[his_seg] + (points[his_seg + 1] - points[his_seg]) * mid2;
      double one = answer_for_both(me, he1, my_seg, his_seg);
      double two = answer_for_both(me, he2, my_seg, his_seg);
      his_min_answer = min({his_min_answer, one, two});
      if (one < two) {
        high = mid2;
      } else {
        low = mid1;
      }
      if (flag) {
        debug() << " ["
                << "his_seg"
                   ": "
                << (his_seg)
                << "] "
                   " ["
                << "rep"
                   ": "
                << (rep)
                << "] "
                   " ["
                << "one"
                   ": "
                << (one)
                << "] "
                   " ["
                << "he1.x"
                   ": "
                << (he1.x)
                << "] "
                   " ["
                << "he1.y"
                   ": "
                << (he1.y) << "] ";
      }
    }
  }
  if (flag) {
    debug() << " ["
            << "his_min_answer"
               ": "
            << (his_min_answer) << "] ";
  }
  return his_min_answer;
}
int main() {
  cin >> n;
  points.resize(n + 1);
  for (P& p : points) {
    p.read();
  }
  segments.resize(n);
  for (int i = 0; i < n; ++i) {
    segments[i] = {points[i], points[i + 1]};
  }
  double my_max_answer = -1;
  for (int my_seg = 0; my_seg < n; ++my_seg) {
    double low = 1e-7, high = 1 - 1e-7;
    for (int rep = 0; rep < 40; ++rep) {
      double mid1 = (3 * low + 2 * high) / 5;
      double mid2 = (2 * low + 3 * high) / 5;
      P me1 = points[my_seg] + (points[my_seg + 1] - points[my_seg]) * mid1;
      P me2 = points[my_seg] + (points[my_seg + 1] - points[my_seg]) * mid2;
      debug() << " ["
              << "me1.x"
                 ": "
              << (me1.x)
              << "] "
                 " ["
              << "me1.y"
                 ": "
              << (me1.y) << "] ";
      double one = answer_for_my_position(me1, my_seg, rep == 39);
      double two = answer_for_my_position(me2, my_seg);
      my_max_answer = max({my_max_answer, one, two});
      if (one > two) {
        high = mid2;
      } else {
        low = mid1;
      }
    }
    debug() << " ["
            << "my_seg"
               ": "
            << (my_seg)
            << "] "
               " ["
            << "low"
               ": "
            << (low)
            << "] "
               " ["
            << "my_max_answer"
               ": "
            << (my_max_answer) << "] ";
  }
  my_max_answer = max(my_max_answer, 1 + 0.9 * 1e-6);
  printf("%.12lf\n", my_max_answer);
}
