#include <bits/stdc++.h>
using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const db EPS = 1e-9;
const db INF = 1e9;

template<typename T>
void updMin(T& a, T b)
{
    a = min(a, b);
}

template<typename T>
void updMax(T& a, T b)
{
    a = max(a, b);
}

struct Pt
{
	db x, y;
	Pt operator+(const Pt& p) const
	{
		return {x + p.x, y + p.y};
	}
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
    Pt operator*(db d) const
	{
		return {x * d, y * d};
	}
    Pt operator/(db d) const
	{
		return {x / d, y / d};
	}
};
db sq(const Pt& p)
{
	return p.x * p.x + p.y * p.y;
}
db abs(const Pt& p)
{
	return sqrt(sq(p));
}
int sgn(db x)
{
	return (EPS < x) - (x < -EPS);
}
Pt perp(const Pt& p)
{
	return {-p.y, p.x};
}
db dot(const Pt& p, const Pt& q)
{
	return p.x * q.x + p.y * q.y;
}
db cross(const Pt& p, const Pt& q)
{
	return p.x * q.y - p.y * q.x;
}
struct Line
{
	Pt n;
	db c;
	Line(const Pt& p, const Pt& q):
		n(perp(q - p)), c(-dot(n, p)) {}
};
bool parallel(const Line& l1, const Line& l2)
{
	return sgn(cross(l1.n, l2.n)) == 0;
}
Pt inter(const Line& l1, const Line& l2)
{
	db d = cross(l1.n, l2.n);
	assert(sgn(d) != 0);
	return perp(l2.n * l1.c - l1.n * l2.c) / d;
}
db areaTriangle(const Pt& a, const Pt& b, const Pt& c)
{
	return abs(cross(b - a, c - a)) / 2.0;
}
db areaPolygon(const vector<Pt>& v)
{
	db area = 0.0;
	int n = SZ(v);
	FOR(i, 0, n)
		area += cross(v[i], v[(i + 1) % n]);
	return abs(area) / 2.0;
}

int main()
{
	ios::sync_with_stdio(0); 
	cin.tie(0);
    cout << fixed << setprecision(10);
	int n;
    cin >> n;
    vector<Pt> v(n);
    for (Pt& p : v)
        cin >> p.x >> p.y;
    db totArea = areaPolygon(v);
    db ansMin = INF, ansMax = 0;
    FOR(i, 0, n)
    {
        db s = 0;
        FOR(j, i + 1, i + n)
        {
            s += areaTriangle(v[i], v[(j - 1) % n], v[j % n]);
            db tr1 = areaTriangle(v[i], v[(i + 1) % n], v[j % n]);
            db tr2 = areaTriangle(v[i], v[j % n], v[(j + 1) % n]);
            if (sgn(s - tr1 - totArea / 2) <= 0 && sgn(totArea / 2 - s - tr2) <= 0)
            {
                function<pair<db, db>(db)> f = [&](db alpha) -> pair<db, db>
                {
                    Pt p = v[i] + (v[(i + 1) % n] - v[i]) * alpha;
                    db tr = areaTriangle(p, v[j % n], v[(j + 1) % n]);
                    db beta = (totArea / 2 - s + alpha * tr1) / tr;
                    Pt q = v[j % n] + (v[(j + 1) % n] - v[j % n]) * beta;
                    return {sq(q - p), beta};
                };
                db l = 0, r = 1;
                FOR(it, 0, 74)
                {
                    db m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
                    if (f(m1) < f(m2))
                        r = m2;
                    else
                        l = m1;
                }
                auto [sqd, beta] = f((l + r) / 2);
                if (sgn(beta) >= 0 && sgn(beta - 1) <= 0)
                {
                    updMin(ansMin, sqrt(sqd));
                }
            }
            if (sgn(s - totArea / 2) <= 0 && sgn(totArea / 2 - s - tr2) <= 0)
            {
                Pt p = v[j % n] + (v[(j + 1) % n] - v[j % n]) * ((totArea / 2 - s) / tr2);
                updMax(ansMax, abs(p - v[i]));
            }
        }
    }
    cout << ansMin << "\n" << ansMax << "\n";
	return 0;
}