You are given a convex polygon P with n distinct vertices p1, p2, ..., pn. Vertex pi has coordinates (xi, yi) in the 2D plane. These vertices are listed in clockwise order.

You can choose a real number D and move each vertex of the polygon a distance of at most D from their original positions.

Find the maximum value of D such that no matter how you move the vertices, the polygon does not intersect itself and stays convex.

Input

The first line has one integer n (4 ≤ n ≤ 1 000) — the number of vertices.

The next n lines contain the coordinates of the vertices. Line i contains two integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th vertex. These points are guaranteed to be given in clockwise order, and will form a strictly convex polygon (in particular, no three consecutive points lie on the same straight line).

Output

Print one real number D, which is the maximum real number such that no matter how you move the vertices, the polygon stays convex.

Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.

Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct if <image>.

Examples

Input

4
0 0
0 1
1 1
1 0


Output

0.3535533906


Input

6
5 0
10 0
12 -4
10 -8
5 -8
3 -4


Output

1.0000000000

Note

Here is a picture of the first sample

<image>

Here is an example of making the polygon non-convex.

<image>

This is not an optimal solution, since the maximum distance we moved one point is  ≈ 0.4242640687, whereas we can make it non-convex by only moving each point a distance of at most  ≈ 0.3535533906.
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
struct point;
struct vec;
struct line;
struct circle;
struct triangle;
long double to_rad(long double theta);
long double to_deg(long double theta);
long double dist(point p, point q);
point middle(point p, point q);
point translate(point p, vec u);
long double norm_sq(vec u);
long double dot(vec u, vec v);
long double cross(vec u, vec v);
bool are_parallel(line l, line d);
bool are_same(line l, line d);
long double dist_to_line(point p, point a, point b);
bool ccw(point p, point q, point r);
bool collinear(point p, point q, point r);
long double angle(point a, point o, point b);
point rotate(point p, long double theta, point q);
point intersection(line l, line d);
bool check_range(long double v, long double l1, long double r1, long double l2,
                 long double r2);
point segment_intersection(point p, point q, point r, point t);
bool point_on_ray(point p, point a, point b);
bool point_on_segment(point p, point a, point b);
point projection(point p, point a, point b);
long double dist_to_segment(point p, point a, point b);
point reflection(point p, point a, point b);
line perpendicular(point p, point a, point b);
line bisector(point a, point o, point b);
circle find_circle(point p, point q, long double r);
circle in_circle(triangle t);
circle circum_circle(triangle t);
long double perimeter(vector<point> P);
long double area(vector<point> P);
bool is_convex(vector<point> P);
bool is_in(point p, vector<point> P);
vector<point> cut(vector<point> P, point a, point b);
bool ch_cmp(point a, point b);
vector<point> convex_hull(vector<point> P);
void print(vector<point> P);
struct point {
  long double x, y;
  point(long double nx = 0, long double ny = 0) { x = nx, y = ny; }
  bool operator==(point p) {
    return fabs(x - p.x) <= (1e-9) && fabs(y - p.y) <= (1e-9);
  }
  bool operator!=(point p) {
    return fabs(x - p.x) > (1e-9) || fabs(y - p.y) > (1e-9);
  }
  bool operator<(point p) {
    if (fabs(x - p.x) > (1e-9)) return x < p.x - (1e-9);
    return y < p.y - (1e-9);
  }
  friend istream &operator>>(istream &is, point &p) { return is >> p.x >> p.y; }
  friend ostream &operator<<(ostream &os, point p) {
    return os << p.x << ' ' << p.y;
  }
};
struct vec {
  long double x, y;
  vec(long double nx = 0, long double ny = 0) { x = nx, y = ny; }
  vec(point p, point q) { x = q.x - p.x, y = q.y - p.y; }
  vec operator+(vec u) { return vec(x + u.x, y + u.y); }
  vec operator-(vec u) { return vec(x - u.x, y - u.y); }
  vec operator*(long double k) { return vec(k * x, k * y); }
  friend istream &operator>>(istream &is, vec u) { return is >> u.x >> u.y; }
  friend ostream &operator<<(ostream &os, vec u) {
    return os << u.x << ' ' << u.y;
  }
};
struct line {
  long double a, b, c;
  line(long double na = 0, long double nb = 0, long double nc = 0) {
    a = na, b = nb, c = nc;
  }
  line(point p, point q) {
    long double dx = q.x - p.x;
    long double dy = q.y - p.y;
    if (fabs(dx) <= (1e-9)) {
      a = 1, b = 0, c = -p.x;
      return;
    }
    a = -dy / dx;
    b = 1.0;
    c = dy / dx * p.x - p.y;
  }
  line(point p, long double m) {
    a = -m;
    b = 1.0;
    c = -(a * p.x + p.y);
  }
  pair<point, point> to_points() {
    point p, q;
    if (fabs(b) <= (1e-9))
      p.x = -c / a, q.x = p.x, p.y = 0, q.y = 1;
    else
      p.x = 0, q.x = 1, p.y = -(a * p.x + c), q.y = -(a * q.x + c);
    return make_pair(p, q);
  }
};
struct circle {
  long double x, y, r;
  circle(point c = point(0, 0), long double nr = 0) {
    x = c.x, y = c.y, r = nr;
  }
  int is_in(point p) {
    long double dx = p.x - x, dy = p.y - y;
    long double d = dx * dx + dy * dy, R = r * r;
    return (d < R - (1e-9)) ? 0 : (fabs(d - R) <= (1e-9)) ? 1 : 2;
  }
  long double perimeter(long double theta = 360) {
    theta = to_rad(theta);
    return theta * r;
  }
  long double area(long double theta = 360) {
    theta = to_rad(theta);
    return theta * r * r / 2;
  }
};
struct triangle {
  point A, B, C;
  long double a, b, c;
  triangle(long double na = 0, long double nb = 0, long double nc = 0) {
    a = na, b = nb, c = nc;
  }
  triangle(point nA, point nB, point nC) {
    A = nA, B = nB, C = nC;
    c = dist(A, B), a = dist(B, C), b = dist(C, A);
  }
  bool is_triangle() {
    return a + b > c + (1e-9) && b + c > a + (1e-9) && c + a > b + (1e-9);
  }
  long double perimeter() { return a + b + c; }
  long double area() {
    long double s = perimeter() / 2;
    return sqrt(s * (s - a) * (s - b) * (s - c));
  }
};
long double to_rad(long double theta) { return theta * acos(-1.0) / 180; }
long double to_deg(long double theta) { return theta * 180 / acos(-1.0); }
long double dist(point p, point q) { return hypot(p.x - q.x, p.y - q.y); }
point middle(point p, point q) {
  return point((p.x + q.x) / 2, (p.y + q.y) / 2);
}
point translate(point p, vec u) { return point(p.x + u.x, p.y + u.y); }
long double norm_sq(vec u) { return u.x * u.x + u.y * u.y; }
long double dot(vec u, vec v) { return u.x * v.x + u.y * v.y; }
long double cross(vec u, vec v) { return u.x * v.y - u.y * v.x; }
bool are_parallel(line l, line d) {
  return fabs(l.a - d.a) <= (1e-9) && fabs(l.b - l.b) <= (1e-9);
}
bool are_same(line l, line d) {
  return are_parallel(l, d) && fabs(l.c - d.c) <= (1e-9);
}
long double dist_to_line(point p, point a, point b) {
  return dist(p, projection(p, a, b));
}
bool ccw(point p, point q, point r) {
  return cross(vec(p, q), vec(p, r)) > 0 + (1e-9);
}
bool collinear(point p, point q, point r) {
  return fabs(cross(vec(p, q), vec(p, r))) <= (1e-9);
}
long double angle(point a, point o, point b) {
  vec oa = vec(o, a), ob = vec(o, b);
  return acos(dot(oa, ob) / sqrt(norm_sq(oa) * norm_sq(ob)));
}
point rotate(point p, long double theta, point q = point(0, 0)) {
  vec oq = vec(point(0, 0), q);
  p = translate(p, oq * -1);
  theta = to_rad(theta);
  long double x = p.x * cos(theta) - p.y * sin(theta);
  long double y = p.x * sin(theta) + p.y * cos(theta);
  p = point(x, y);
  p = translate(p, oq);
  return p;
}
point intersection(line l, line d) {
  if (are_parallel(l, d)) return point((1000000000), (1000000000));
  point p;
  p.x = (d.b * l.c - l.b * d.c) / (d.a * l.b - l.a * d.b);
  if (fabs(l.b) > (1e-9))
    p.y = -(l.a * p.x + l.c);
  else
    p.y = -(d.a * p.x + d.c);
  return p;
}
bool check_range(long double v, long double l, long double r) {
  if (l > r + (1e-9)) swap(l, r);
  if (fabs(r - l) <= (1e-9)) return fabs(v - l) <= (1e-9);
  return l < v - (1e-9) && v < r - (1e-9);
  return l <= v + (1e-9) && v <= r + (1e-9);
}
point segment_intersection(point p, point q, point r, point t) {
  point c = intersection(line(p, q), line(r, t));
  if (point_on_segment(c, p, q) && point_on_segment(c, r, t)) return c;
  return point((1000000000), (1000000000));
}
bool point_on_ray(point p, point a, point b) {
  vec ap = vec(a, p), ab = vec(a, b);
  return collinear(p, a, b) && dot(ap, ab) >= -(1e-9);
}
bool point_on_segment(point p, point a, point b) {
  return point_on_ray(p, a, b) && point_on_ray(p, b, a);
}
point projection(point p, point a, point b) {
  vec ap = vec(a, p), ab = vec(a, b);
  long double u = dot(ap, ab) / norm_sq(ab);
  return translate(a, ab * u);
}
long double dist_to_segment(point p, point a, point b) {
  vec ap = vec(a, p), ab = vec(a, b);
  long double u = dot(ap, ab) / norm_sq(ab);
  if (u < 0 - (1e-9)) return dist(p, a);
  if (u > 1 + (1e-9)) return dist(p, b);
  return dist_to_line(p, a, b);
}
point reflection(point p, point a, point b) {
  point c = projection(p, a, b);
  vec pc = vec(p, c);
  return translate(p, pc * 2);
}
line perpendicular(point p, point a, point b) {
  if (!collinear(p, a, b)) return line(p, projection(p, a, b));
  line l = line(a, b);
  if (fabs(l.b) <= (1e-9)) return line(p, point(p.x + 1, p.y));
  if (fabs(l.a) <= (1e-9)) return line(p, point(p.x, p.y + 1));
  return line(p, 1 / l.a);
}
line bisector(point a, point o, point b) {
  long double ratio = dist(o, a) / dist(o, b);
  ratio /= ratio + 1;
  vec ab = vec(a, b);
  point c = translate(a, ab * ratio);
  return line(o, c);
}
circle find_circle(point p, point q, long double r) {
  point m = middle(p, q);
  vec mp = vec(m, p);
  long double mc = r * r - norm_sq(mp);
  if (mc < 0 - (1e-9)) return circle();
  mc = sqrt(mc);
  long double u = mc / dist(m, p);
  point c = translate(m, mp * u);
  c = rotate(c, 90, m);
  return circle(c, r);
}
circle in_circle(triangle t) {
  long double r = 2 * t.area() / t.perimeter();
  if (fabs(r) <= (1e-9)) return circle();
  line l = bisector(t.B, t.A, t.C);
  line d = bisector(t.C, t.B, t.A);
  point c = intersection(l, d);
  return circle(c, r);
}
circle circum_circle(triangle t) {
  long double r = (t.a * t.b * t.c) / (4 * t.area());
  if (fabs(r) <= (1e-9)) return circle();
  line l = perpendicular(middle(t.A, t.B), t.A, t.B);
  line d = perpendicular(middle(t.A, t.C), t.A, t.C);
  point c = intersection(l, d);
  return circle(c, r);
}
point pivot;
long double perimeter(vector<point> P) {
  int n = P.size();
  long double ret = 0;
  for (int i = 0; i < n - 1; i++) ret += dist(P[i], P[i + 1]);
  return ret;
}
long double area(vector<point> P) {
  P.push_back(P[0]);
  int n = P.size();
  long double ret = 0;
  long double x1, x2, y1, y2;
  for (int i = 0; i < n - 1; i++) {
    x1 = P[i].x, x2 = P[i + 1].x;
    y1 = P[i].y, y2 = P[i + 1].y;
    ret += x1 * y2 - x2 * y1;
  }
  ret /= 2, ret = fabs(ret);
  return ret;
}
bool is_convex(vector<point> P) {
  int n = P.size();
  if (n <= 3) return false;
  bool turn = ccw(P[0], P[1], P[2]);
  for (int i = 1; i < n - 1; i++)
    if (ccw(P[i], P[i + 1], P[i + 2 != n ? i + 2 : 1]) != turn) return false;
  return true;
}
bool is_in(point p, vector<point> P) {
  int n = P.size();
  long double sum = 0;
  for (int i = 0; i < n - 1; i++)
    if (ccw(P[i], p, P[i + 1]))
      sum += angle(P[i], p, P[i + 1]);
    else
      sum -= angle(P[i], p, P[i + 1]);
  sum = fabs(sum);
  return fabs(sum - 2 * acos(-1.0)) <= (1e-9);
}
vector<point> cut(vector<point> P, point a, point b) {
  int n = P.size();
  vector<point> ret;
  for (int i = 0; i < n; i++) {
    long double left1 = cross(vec(a, b), vec(a, P[i]));
    long double left2 = (i != n - 1) ? cross(vec(a, b), vec(a, P[i + 1])) : 0;
    if (left1 >= -(1e-9)) ret.push_back(P[i]);
    if (left1 * left2 < -(1e-9))
      ret.push_back(intersection(line(a, b), line(P[i], P[i + 1])));
  }
  if (!ret.empty() && ret.front() != ret.back()) ret.push_back(ret.front());
  return ret;
}
bool ch_cmp(point a, point b) {
  if (collinear(pivot, a, b)) return dist(pivot, a) < dist(pivot, b) - (1e-9);
  long double dx1 = a.x - pivot.x, dy1 = a.y - pivot.y;
  long double dx2 = b.x - pivot.x, dy2 = b.y - pivot.y;
  return atan2(dy1, dx1) < atan2(dy2, dx2) - (1e-9);
}
vector<point> convex_hull(vector<point> P) {
  int n = P.size();
  if (n <= 3) {
    if (n != 0 && P[0] != P[n - 1]) P.push_back(P[0]);
    return P;
  }
  int idx = 0;
  for (int i = 1; i < n; i++)
    if (P[idx].y > P[i].y + (1e-9) ||
        (fabs(P[idx].y - P[i].y) <= (1e-9) && P[idx].x < P[i].x - (1e-9)))
      idx = i;
  swap(P[0], P[idx]);
  pivot = P[0];
  sort(P.begin() + 1, P.end(), ch_cmp);
  vector<point> ch;
  ch.push_back(P[n - 1]), ch.push_back(P[0]), ch.push_back(P[1]);
  int i = 2;
  while (i < n) {
    int j = ch.size() - 1;
    if (ccw(ch[j - 1], ch[j], P[i]))
      ch.push_back(P[i]), i++;
    else
      ch.pop_back();
  }
  return ch;
}
void print(vector<point> P) {
  int n = P.size();
  cout << '\n';
  for (int i = 0; i < n; i++) cout << P[i] << '\n';
  cout << '\n';
}
long long n;
long long fix(long long x) {
  x %= n;
  x += n;
  x %= n;
  return x;
}
point p[100009];
int main() {
  cin >> n;
  for (int i = 0; i < n; i++) {
    long long x, y;
    cin >> x >> y;
    p[i] = point(x, y);
  }
  long double ans = 1e17;
  for (int i = 0; i < n; i++) {
    point l = p[fix(i - 1)];
    point r = p[fix(i + 1)];
    ans = min(ans, dist_to_segment(p[i], l, r));
  }
  cout << fixed << setprecision(8) << ans / 2;
}
