#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;
 
template<class A, class B> string to_string(const pair<A, B> &p);
string to_string(const string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) { 
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; 
}
 
void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
 
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

template<class T> 
struct Point {
	using P = Point;
	using type = T;
	static constexpr T eps = 1e-10;
	static constexpr bool isInt = is_integral_v<T>;
	static int sgn(T x) { return (x > eps) - (x < -eps); }
	static int cmp(T x, T y) { return sgn(x - y); }

	T x, y;

	P operator +(P b) const { return P{x + b.x, y + b.y}; }
	P operator -(P b) const { return P{x - b.x, y - b.y}; }
	P operator *(T b) const { return P{x * b, y * b}; }
	P operator /(T b) const { return P{x / b, y / b}; }
	bool operator ==(P b) const { return cmp(x, b.x) == 0 && cmp(y, b.y) == 0; }
	bool operator <(P b) const { return cmp(x, b.x) == 0 ? cmp(y, b.y) < 0: x < b.x; }

	T len2() const { return x * x + y * y; }
	T len() const { return sqrt(x * x + y * y); }

	// dot and cross may lead to big relative error for imprecise point when the result is relatively smaller than the input magnitude.
	T cross(P b) const { return x * b.y - y * b.x; }

	bool is_upper() const { return y > eps || (sgn(y) == 0 && x < -eps); } /// start-hash
	
	// return -1 if a has smaller pollar; return 1 if a has a larger pollar; return 0 o.w.
	// Taking unit makes it slower but it performs as atan2.
	static int argcmp(P a, P b) {
		if (a.is_upper() != b.is_upper()) return cmp(a.is_upper(), b.is_upper());
		return sgn(b.cross(a));
	} /// end-hash

	// Returns the signed distance to line $ab$. $a$ and $b$ should be distinct.
	T dis_to_line(P a, P b) const { /// start-hash
		assert((a - b).len2() > P::eps);
		if (isInt) return (*this - a).cross(b - a);
		else return (*this - a).cross(b - a) / (b - a).len();
	} /// end-hash
	
	friend string to_string(P p) { return "(" + to_string(p.x) + ", " + to_string(p.y) + ")"; }
};


/**
 * Author: Yuhao Yao
 * Date: 22-10-02
 * Description: Compute the intersection of Half Planes, which is a Convex hull. A Half Plane is represented by the left hind side of a directed line $ab$ (i.e. counter-clockwise).
 *  Please make sure the intersection of Half Planes in $ls$ is bounded.
 *  Also make sure that there is no HalfPlane with direction $dir() = (0, 0)$.
 *  If the intersection is empty, then the returned vector has a size at most 2.
 *  Otherwise a Convex hull is returned, which has no consectuive collinear points.
 *  Only works for \textbf{double} and \textbf{long double}.
 *  \textbf{Needed function(s): argcmp, dis_to_line}.
 * Status: tested on https://official.contest.yandex.com/opencupXXII/contest/38278/problems/K/, https://www.luogu.com.cn/problem/P6505, https://qoj.ac/contest/782/problem/2162.
 */
template<class P> /// start-hash
struct HalfPlane {
	P a, b; // make sure a != b.
	P dir() const { return b - a; }
	bool include(P p) const { return p.dis_to_line(a, b) < -P::eps; }
	bool operator <(const HalfPlane &rhs) const { 
		return P::argcmp(dir(), rhs.dir()) < 0;
	}
	pair<bool, P> capLL(const HalfPlane &rhs) const {
		auto s0 = (a - rhs.a).cross(rhs.dir());
		auto s1 = (a - b).cross(rhs.dir());
		if (P::sgn(s1) == 0) return {false, P{}};
		return {true, a + (b - a) * s0 / s1};
	}
}; /// end-hash

template<class P, class HP = HalfPlane<P>> /// start-hash
vector<P> HPI(vector<HalfPlane<P>> hps) {
	// please make sure hps is closed.  
	auto Samedir = [](HP &r, HP &s) { return (r < s || s < r) == 0; };
	sort(all(hps), [&](HP &r, HP &s) { return Samedir(r, s) ? s.include(r.a) : r < s; });

	// assuming hps is closed then the intersect function should be fine.
	auto check = [](HP &w, HP &r, HP &s) {
		auto [res, p] = r.capLL(s);
		if (res == 0) return false; // if r and s are parallel then it implies the intersection is empty.
		return w.include(p);
	};
	
	deque<HP> q;
	rep(i, 0, sz(hps) - 1) {
		if (i && Samedir(hps[i], hps[i - 1])) continue;
		while (sz(q) > 1 && !check(hps[i], q.end()[-2], q.end()[-1])) q.pop_back();
		while (sz(q) > 1 && !check(hps[i], q[0], q[1])) q.pop_front();
		q.push_back(hps[i]);
	}
	while (sz(q) > 2 && !check(q[0], q.end()[-2], q.end()[-1])) q.pop_back();
	while (sz(q) > 2 && !check(q.back(), q[0], q[1])) q.pop_front();
	vector<P> res;
	rep(i, 0, sz(q) - 1) res.push_back(q[i].capLL(q[(i + 1) % sz(q)]).second);
	return res;
} /// end-hash

/**
 * Author: Yuhao Yao
 * Date: 22-08-29
 * Description: Calculate the signed area of a simple Polygon $poly$. Positive area means counter-clockwise order.
 * Time: O(|poly|).
 * Status: tested on https://codeforces.com/gym/101673/problem/A.
 */
template<class T>
T PolyArea(const vector<Point<T>> &poly) {
	if (poly.empty()) return 0;
	T sum = 0;
	rep(i, 0, sz(poly) - 1) sum += (poly[i] - poly[0]).cross(poly[(i + 1) % sz(poly)] - poly[0]);
	return sum / 2;
}


int main() {
	ios::sync_with_stdio(0); cin.tie(0);
	using T = double;
	using P = Point<T>;
	using HP = HalfPlane<P>;
	
	int n; cin >> n;
	vector<P> as(n);
	for (auto &[x, y]: as) cin >> x >> y;

	vi fars(n);
	int ptr = 1;
	rep(i, 0, n - 1) {
		P a = as[i];
		P b = as[(i + 1) % n];
		chmax(ptr, i + 1);
		while (ptr < i + n && (b - a).cross(as[(ptr + 1) % n] - as[ptr % n]) > P::eps) {
			ptr++;
		}
		fars[i] = ptr % n;
	}

	auto check = [&](T ratio) {
		vector<HP> hps;
		rep(i, 0, n - 1) {
			auto a = as[i];
			auto b = as[(i + 1) % n];
			auto c = as[fars[i]];
			auto d = c + (a - c) * ratio / (ratio + 1);
			auto e = c + (b - c) * ratio / (ratio + 1);
			hps.push_back({d, e});
		}
		auto hull = HPI(hps);
		if (sz(hull) >= 3) return 1;
		else return 0;
	};

	T lo = 1, hi = 2;
	rep(rd, 1, 35) {
		T mid = (lo + hi) / 2;
		if (check(mid)) hi = mid;
		else lo = mid;
	}
	T ans = (lo + hi) / 2;
	printf("%.10f\n", (double) ans);
	return 0;
}