#include <bits/stdc++.h>
const double EPS = 1e-6;
const double PI = 3.14159265359;
const double MAX_COORD = 1.1e9;
const double INF = 100 * MAX_COORD;
class Vector {
 private:
  static bool nearly_equal(double a, double b) {
    return (std::abs(a - b) < EPS);
  }

 public:
  double x, y;
  Vector(double pX = 0, double pY = 0) : x(pX), y(pY) {}
  double len_sqr() const { return x * x + y * y; }
  double len() const { return std::sqrt(len_sqr()); }
  Vector normal() const {
    double l = len();
    return Vector(x / l, y / l);
  }
  Vector &operator+=(const Vector &v) {
    x += v.x;
    y += v.y;
    return *this;
  }
  Vector &operator-=(const Vector &v) {
    x -= v.x;
    y -= v.y;
    return *this;
  }
  Vector &operator*=(double n) {
    x *= n;
    y *= n;
    return *this;
  }
  Vector operator-() { return Vector(-x, -y); }
  friend Vector operator+(Vector v, const Vector &u) { return v += u; }
  friend Vector operator-(Vector v, const Vector &u) { return v -= u; }
  friend Vector operator*(Vector v, double n) { return v *= n; }
  friend double operator*(Vector v, const Vector &u) {
    return v.x * u.x + v.y * u.y;
  }
  friend double operator^(Vector v, const Vector &u) {
    return v.x * u.y - v.y * u.x;
  }
  friend bool operator==(const Vector &v, const Vector &u) {
    return nearly_equal(v.x, u.x) && nearly_equal(v.y, u.y);
  }
  friend bool operator!=(const Vector &v, const Vector &u) { return !(v == u); }
};
struct Line {
  double x, y, c;
  Line(const Vector &v1 = Vector(), const Vector &v2 = Vector()) {
    x = v1.y - v2.y;
    y = v2.x - v1.x;
    c = v1.x * v2.y - v2.x * v1.y;
  }
  std::vector<Vector> intersect_circle(double r) {
    std::vector<Vector> ans;
    if (x != 0) {
      double d = y * y * c * c - (y * y + x * x) * (c * c - x * x * r * r);
      if (d < 0) {
        return ans;
      }
      double dSqrt = std::sqrt(d);
      Vector v1, v2;
      v1.y = (-y * c + dSqrt) / (x * x + y * y);
      v2.y = (-y * c - dSqrt) / (x * x + y * y);
      v1.x = (-c - y * v1.y) / x;
      v2.x = (-c - y * v2.y) / x;
      ans.push_back(v1);
      if (v1 != v2) {
        ans.push_back(v2);
      }
    } else {
      double d = x * x * c * c - (x * x + y * y) * (c * c - y * y * r * r);
      if (d < 0) {
        return ans;
      }
      double dSqrt = std::sqrt(d);
      Vector v1, v2;
      v1.x = (-x * c + dSqrt) / (x * x + y * y);
      v2.x = (-x * c - dSqrt) / (x * x + y * y);
      v1.y = (-c - x * v1.x) / y;
      v2.y = (-c - x * v2.x) / y;
      ans.push_back(v1);
      if (v1 != v2) {
        ans.push_back(v2);
      }
    }
    return ans;
  }
};
struct LineSegment {
 private:
  bool between(double v, double e1, double e2) {
    if (e1 < e2) {
      return ((v + EPS > e1) && (v < e2 + EPS));
    } else {
      return ((v + EPS > e2) && (v < e1 + EPS));
    }
  }

 public:
  Vector a, b;
  Line l;
  LineSegment(Vector pA = Vector(), Vector pB = Vector()) : a(pA), b(pB) {
    l = Line(a, b);
  }
  std::vector<Vector> intersect_circle(double r) {
    std::vector<Vector> pot = l.intersect_circle(r);
    std::vector<Vector> ans;
    for (const Vector &v : pot) {
      if (between(v.x, a.x, b.x) && between(v.y, a.y, b.y)) {
        ans.push_back(v);
      }
    }
    if (ans.size() == 2) {
      if (between(ans[0].x, ans[1].x, b.x) &&
          between(ans[0].y, ans[1].y, b.y)) {
        std::swap(ans[0], ans[1]);
      }
    }
    return ans;
  }
};
std::vector<Vector> poly;
uint32_t maxD;
void input() {
  uint32_t vCnt;
  scanf("%u", &vCnt);
  poly.resize(vCnt);
  for (uint32_t i = 0; i < vCnt; i++) {
    scanf("%lf %lf", &poly[i].x, &poly[i].y);
  }
}
double possib(Vector a, Vector b, Vector c) {
  double area = std::abs((b - a) ^ (c - b));
  double height = area / (a - c).len();
  return height / 2;
}
int main() {
  input();
  double num = INF;
  for (uint32_t i = 0; i < poly.size(); i++) {
    double c = possib(poly[i], poly[(i + 1) % poly.size()],
                      poly[(i + 2) % poly.size()]);
    num = std::min(num, c);
  }
  printf("%.7lf\n", num);
}
