#include <bits/stdc++.h>
int nextInt() {
  int x;
  scanf("%d", &x);
  return x;
}
double nextDouble() {
  double x;
  scanf("%lf", &x);
  return x;
}
long long nextLong() {
  long long x;
  scanf("%I64d", &x);
  return x;
}
char nextChar() {
  char x;
  scanf("%c", &x);
  return x;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long pow(long long a, long long b, long long MOD) {
  long long x = 1, y = a;
  while (b > 0) {
    if (b % 2 == 1) {
      x = (x * y);
      if (x > MOD) x %= MOD;
    }
    y = (y * y);
    if (y > MOD) y %= MOD;
    b /= 2;
  }
  return x;
}
int countBitSet(long long n) {
  int ans = 0;
  while (n != 0) {
    n -= (n & -n);
    ++ans;
  }
  return ans;
}
long long mod = 1e9 + 7;
const int N = 100100;
const int M = 10111;
const double EPS = (double)1e-6;
const double INF = 1e50;
using namespace std;
double fgcd(double x, double y) {
  if (y < EPS)
    return x;
  else
    return fgcd(y, fmod(x, y));
}
bool eq(double x, double y) { return abs(x - y) < EPS; }
bool isInt(double x) {
  int xx = (int)(x + EPS);
  return eq(x, xx);
}
struct Point {
 private:
  double x;
  double y;

 public:
  Point() {}
  Point(double x, double y) : x(x), y(y) {}
  Point(const Point &p) : x(p.x), y(p.y) {}
  void read() { scanf("%lf %lf", &x, &y); }
  double getX() { return this->x; }
  double getY() { return this->y; }
  Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
  Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
  Point operator*(double c) const { return Point(x * c, y * c); }
  Point operator/(double c) const { return Point(x / c, y / c); }
};
struct Line {
 private:
  Point a;
  Point b;
  double m;
  double c;

 public:
  Line() {}
  Line(Point a, Point b) : a(a), b(b) {
    if (this->hasDefinedSlope()) {
      this->m = (a.getY() - b.getY()) / (a.getX() - b.getX());
      this->c = -a.getX() * m + a.getY();
    } else {
      this->c = a.getX();
    }
  }
  double getLength() {
    return sqrt((a.getX() - b.getX()) * (a.getX() - b.getX()) +
                (a.getY() - b.getY()) * (a.getY() - b.getY()));
  }
  bool hasDefinedSlope() {
    return (this->m != INF) && !(abs(a.getX() - b.getX()) < EPS);
  }
  double getSolpe() { return this->m; }
  void setSlope(double m) { this->m = m; }
  double getDelta() { return this->c; }
  void setDelta(double c) { this->c = c; }
  void setOnePoint(Point p) { this->a = p; }
  bool isParallelToX() {
    return this->hasDefinedSlope() && this->getSolpe() == 0;
  }
  bool isParallelToY() { return !this->hasDefinedSlope(); }
  bool isParallelToLine(Line line) {
    if (this->isParallelToY() && line.isParallelToY()) return true;
    if (abs(this->getSolpe() - line.getSolpe()) < EPS) return true;
    return false;
  }
  Point getMidPoint() { return (this->a + this->b) / 2.0; }
  Line getPerpendicularBisector() {
    Point p = this->getMidPoint();
    Line line;
    line.setOnePoint(p);
    if (this->isParallelToX()) {
      line.setSlope(INF);
      line.setDelta(p.getX());
    } else if (this->isParallelToY()) {
      line.setSlope(0);
      line.setDelta(p.getY());
    } else {
      double mm = -1.0 / this->getSolpe();
      line.setSlope(mm);
      line.setDelta(-p.getX() * mm + p.getY());
    }
    return line;
  }
  Point getIntersectionPoint(Line line) {
    if (this->isParallelToLine(line)) return Point(INF, INF);
    if (this->isParallelToX()) {
      if (line.isParallelToY())
        return Point(line.getDelta(), this->getDelta());
      else
        return Point((this->getDelta() - line.getDelta()) / line.getSolpe(),
                     this->getDelta());
    } else if (this->isParallelToY()) {
      if (line.isParallelToX())
        return Point(this->getDelta(), line.getDelta());
      else
        Point(this->getDelta(),
              line.getSolpe() * this->getDelta() + line.getDelta());
    } else if (line.isParallelToX()) {
      return Point((line.getDelta() - this->getDelta()) / this->getSolpe(),
                   line.getDelta());
    } else if (line.isParallelToY()) {
      return Point(line.getDelta(),
                   this->getSolpe() * line.getDelta() + this->getDelta());
    }
    double x = (line.getDelta() - this->getDelta()) /
               (this->getSolpe() - line.getSolpe());
    double y = this->getSolpe() * x + this->getDelta();
    return Point(x, y);
  }
  double getDistanceToPoint(Point p) {
    if (this->isParallelToX()) return abs(p.getY() - this->a.getY());
    if (this->isParallelToY()) return abs(p.getX() - this->a.getX());
    double t1 = a.getY() - b.getY();
    double t2 = b.getX() - a.getX();
    double t3 = this->getDelta() * (a.getX() - b.getX());
    return (t1 * p.getX() + t2 * p.getY() + t3) / sqrt(t1 * t1 + t2 * t2);
  }
};
struct Vector {
 private:
  double x;
  double y;

 public:
  Vector() {}
  Vector(Point a, Point b) {
    x = b.getX() - a.getX();
    y = b.getY() - a.getY();
  }
  double dotProduct(Vector v) { return this->x * this->y + v.x * v.y; }
  double getLength() { return sqrt(this->x * this->x + this->y * this->y); }
  double getAngle(Vector v) {
    return acos(this->dotProduct(v) / (this->getLength() * v.getLength()));
  }
  double getX() { return x; }
  double getY() { return y; }
};
Point a[N];
int main() {
  int n = nextInt();
  for (int i = 0; i < n; i++) {
    a[i].read();
  }
  double ans = 1e50;
  for (int i = 0; i < n; i++) {
    int j = i > 0 ? i - 1 : n - 1;
    int k = j > 0 ? j - 1 : n - 1;
    Line line(a[k], a[i]);
    ans = min(ans, line.getDistanceToPoint(a[j]));
  }
  cout << fixed << setprecision(10) << ans / 2.0 << endl;
}
