You are given a convex polygon *P* with *n* distinct vertices *p*<sub class="lower-index">1</sub>, *p*<sub class="lower-index">2</sub>, ..., *p*<sub class="lower-index">*n*</sub>. Vertex *p*<sub class="lower-index">*i*</sub> has coordinates (*x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub>) 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.
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 *x*<sub class="lower-index">*i*</sub> and *y*<sub class="lower-index">*i*</sub> ( - 10<sup class="upper-index">9</sup> ≤ *x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>) — 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).
Here is a picture of the first sample

<img class="tex-graphics" src="https://espresso.codeforces.com/f83aa076d2f437f9bb785cae769c3ae310eff351.png" style="max-width: 100.0%;max-height: 100.0%;"/>

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

<img class="tex-graphics" src="https://espresso.codeforces.com/fbadb81630251ca642bd4ddf9088876ade761630.png" style="max-width: 100.0%;max-height: 100.0%;"/>

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.
4
0 0
0 1
1 1
1 0
0.3535533906
6
5 0
10 0
12 -4
10 -8
5 -8
3 -4
1.0000000000
19
449447997 711296339
530233434 692216537
535464528 613140435
535533467 100893188
530498867 -265063956
519107979 -271820709
482156929 -287792333
-303730271 -287970295
-416935204 -263348201
-443613873 -249980523
-453444829 -173903413
-462102798 -80789280
-462064673 -13220755
-461368561 482595837
-457749751 687048095
-448625206 709399396
-145117181 710688825
159099640 711650577
400454061 711503381
24967.1394973334
4
0 0
0 10
10 10
6 4
0.7071067812
4
-1000000000 -1000000000
-999999999 -999999999
1000000000 999999999
0 -1
0.0000000000
4
-1000000000 -1000000000
-1000000000 1000000000
1000000000 1000000000
1000000000 -1000000000
707106781.1865475000
4
-100000 -100000
-99999 -99999
100000 99999
0 -100
0.0000017678
4
-10000 -10000
-9999 -9999
10000 9999
0 -1000
0.0000176781
5
0 0
0 10
10 10
20 0
10 -1
0.5000000000
5
10 -1
0 0
0 10
10 10
20 0
0.5000000000
4
1000000000 1000000000
1000000000 -1000000000
-1000000000 -1000000000
-1000000000 1000000000
707106781.1865475000
4
2 0
0 0
0 14
8 14
0.8682431421
4
0 0
1 100
100 0
1 -100
0.5000000000
4
-1000000000 1000000000
1000000000 500000000
1000000000 -1000000000
-500000000 -1000000000
530330085.8899106400
#include <bits/stdc++.h>

#define __INIT_CC__ ios::sync_with_stdio(false); \
	cin.tie(0);

#ifdef __WIN32__
	char getchar_unlocked() {return getchar();}
#endif

#define FOR(_i,_n,_m) for(int (_i)=(_n),_t=(_m);_i<(_t);++(_i))
#define FORN(_i,_n,_m) for(int (_i)=(_n),_t=(_m);_i<=(_t);++(_i))
#define FORD(_i,_n,_m) for(int (_i)=(_n),_t=(_m);_i>=(_t);--(_i))
#define FORLL(_i,_n,_m) for(long long (_i)=(_n),_t=(_m);_i<(_t);++(_i))
#define FORNLL(_i,_n,_m) for(long long (_i)=(_n),_t=(_m);(_i)<=(_t);++(_i))
#define FORDLL(_i,_n,_m) for(long long (_i)=(_n),_t=(_m);(_i)>=(_t);--(_i))
#define FOREACH(_i,_a) for (__typeof(_a.begin()) _i=_a.begin();_i!=_a.end();++_i)
#define RESET(_a,_value) memset(_a,_value,sizeof(_a))
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define ff first
#define ss second
#define mp make_pair
#define SIZE(_a) (int)_a.size()
#define VSORT(_a) sort(_a.begin(),_a.end())
#define SSORT(_a,_val) sort(_a,_a+(_val))
#define ALL(_a) _a.begin(),_a.end()
#define mt make_tuple
#define _get(_tuple,_i) get<_i>(_tuple)
#define eb emplace_back
 
using namespace std;
 
const int dr[] = { 1, 0,-1, 0, 1, 1,-1,-1};
const int dc[] = { 0, 1, 0,-1, 1,-1,-1, 1};
const double eps = 1e-9;
typedef vector<int> vi;
typedef pair<int,int> ii;
typedef vector<ii> vii;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
typedef pair<double,double> pdd;
typedef vector<pdd> vpdd;
const int INF = 0x7FFFFFFF;
const ll INFLL = 0x7FFFFFFFFFFFFFFFLL;
const double pi = acos(-1);

template <class T> T take(queue<T> &O) {T tmp=O.front();O.pop();return tmp;}
template <class T> T take(stack<T> &O) {T tmp=O.top();O.pop();return tmp;}
template <class T> T take(priority_queue<T> &O) {T tmp=O.top();O.pop();return tmp;}
template <class T> inline void getint(T &num)
{
	bool neg = 0;
	num = 0;
	char c;
	while ((c = getchar_unlocked()) && (!isdigit(c) && c != '-'));
	if (c == '-')
	{
		neg = 1;
		c = getchar_unlocked();
	}
	do num = num * 10 + c - '0';
	while ((c = getchar_unlocked()) && isdigit(c));
	if (neg) num = -num;
}

template <class T> inline bool inRange(T z, T a, T b){return a <= z && z <= b;}

void OPEN(string in = "input.txt",string out = "output.txt")
{
	freopen(in.c_str(), "r", stdin);
	freopen(out.c_str(), "w", stdout);
	return ;
}

//using sokokaleb's template v3.1

vpdd vc;
int n;

int main(int argc, char** argv) {
	__INIT_CC__
	cin >> n;
	vc.resize(n);
	for (auto& pt : vc) {
		cin >> pt.ff >> pt.ss;
	}
	vc.pb(vc[0]);
	vc.pb(vc[1]);
	double ans = 1e18;
	FORN (i, 1, n) {
		double ax = vc[i + 1].ff - vc[i - 1].ff,
			   ay = vc[i + 1].ss - vc[i - 1].ss,
			   bx = vc[i].ff - vc[i - 1].ff,
			   by = vc[i].ss - vc[i - 1].ss;
		double ang = (ax * bx + ay * by) / (hypot(ax, ay) * hypot(bx, by));
		ang = acos(ang);
		double jarak = abs(sin(ang)) * hypot(bx, by);
		ans = min(ans, jarak / 2.0);
	}
	cout << fixed << setprecision(10) << ans << "\n";
}
