#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 vector<LL> VL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef long double db;

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);
}

const db EPS = 1e-9;
const db PI = acos(-1.0);
const db INF = 1e9;

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;
}

db orient(const Pt& p, const Pt& q, const Pt& r)
{
	return cross(q - p, r - p) / abs(q - p);
}

struct Line
{
	Pt n;
	db c;
	Line(const Pt& p, const Pt& q):
		n(perp(q - p)), c(-dot(n, p)) {}
	db side(const Pt& p) const
	{
		return dot(n, p) + c;
	}
	db sqDist(const Pt& p) const
	{
		return side(p) * side(p) / (db)sq(n);
	}
	Pt proj(const Pt& p) const
	{
		return p - n * side(p) / sq(n);
	}
};

bool inDisk(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(dot(a - p, b - p)) <= 0;
}

bool onSegment(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(orient(a, b, p)) == 0 && inDisk(a, b, p);
}

bool inConvexPolygon(const vector<Pt>& v, const Pt& a)
{
	assert(SZ(v) >= 3);
	if (sgn(orient(v.back(), v[0], a)) < 0
		|| sgn(orient(v[0], v[1], a)) < 0)
		return false;
	int i = lower_bound(v.begin() + 2, v.end(), a,
		[&](const Pt& p, const Pt& q)
	{
		return sgn(orient(v[0], p, q)) > 0;
	}) - v.begin();
	return sgn(orient(v[i - 1], v[i], a)) >= 0;
}

vector<Pt> circleLine(const Pt& o, db r, const Line& l)
{
	db h2 = r * r - l.sqDist(o);
	if (sgn(h2) == -1)
		return {};
	Pt p = l.proj(o);
	if (sgn(h2) == 0)
		return {p};
	Pt h = perp(l.n) * sqrt(h2) / abs(l.n);
	return {p - h, p + h};
}

int n;
db r;
vector<Pt> v;
vector<Line> lines;

db area(const Pt& o)
{
	vector<db> angles = {0};
	db res = 0;
	FOR(i, 0, n)
	{
		const Pt& p1 = v[i];
		const Pt& p2 = v[(i + 1) % n];
		vector<Pt> points = {p1, p2};
		vector<Pt> inter = circleLine(o, r, lines[i]);
		for (const Pt& q : inter)
		{
			if (onSegment(p1, p2, q))
			{
				points.PB(q);
				angles.PB(atan2(q.y - o.y, q.x - o.x));
			}
		}
		sort(ALL(points), [&](const Pt& q1, const Pt& q2)
		{
			return sgn(abs(q1 - p1) - abs(q2 - p1)) < 0;
		});
		FOR(j, 0, SZ(points) - 1)
		{
			const Pt& q1 = points[j];
			const Pt& q2 = points[j + 1];
			const Pt& qm = (q1 + q2) / 2;
			if (sgn(abs(qm - o) - r) < 0)
			{
				res += cross(q1, q2);
			}
		}
	}
	sort(ALL(angles));
	angles.PB(angles[0] + 2 * PI);
	FOR(i, 0, SZ(angles) - 1)
	{
		db phi1 = angles[i], phi2 = angles[i + 1], phim = (phi1 + phi2) / 2;
		const Pt& qm = {o.x + r * cos(phim), o.y + r * sin(phim)};
		if (inConvexPolygon(v, qm))
		{
			res += r * (r * (phi2 - phi1)
				+ o.x * (sin(phi2) - sin(phi1))
				- o.y * (cos(phi2) - cos(phi1)));
		}
	}
	return res;
}

db xMin = INF, xMax = -INF, yMin = INF, yMax = -INF;

db solve(db x, db le, db ri)
{
	FOR(i, 0, 74)
	{
		db m1 = le + (ri - le) / 3, m2 = ri - (ri - le) / 3;
		if (area({x, m1}) < area({x, m2}))
			le = m1;
		else
			ri = m2;
	}
	return area({x, (le + ri) / 2});
}

db solve(db x)
{
	db yMid = -47;
	FOR(i, 0, n)
	{
		const Pt& p = v[i];
		const Pt& q = v[(i + 1) % n];
		db xLeft = min(p.x, q.x);
		db xRight = max(p.x, q.x);
		if (sgn(xLeft - x) <= 0 && sgn(x - xRight) <= 0)
		{
			if (sgn(q.x - p.x) == 0)
				yMid = p.y;
			else
				yMid = (q.y - p.y) * (x - p.x) / (q.x - p.x) + p.y;
		}
	}
	assert(sgn(yMin - yMid) <= 0 && sgn(yMid - yMax) <= 0);
	db le = yMin, ri = yMid;
	FOR(i, 0, 74)
	{
		db m = (le + ri) / 2;
		if (sgn(area({x, m})) > 0)
			ri = m;
		else
			le = m;
	}
	db res = solve(x, (le + ri) / 2, yMid);
	le = yMid, ri = yMax;
	FOR(i, 0, 74)
	{
		db m = (le + ri) / 2;
		if (sgn(area({x, m})) > 0)
			le = m;
		else
			ri = m;
	}
	updMax(res, solve(x, yMid, (le + ri) / 2));
	return res;
}

db solve()
{
	for (const Pt& p : v)
	{
		updMin(xMin, p.x);
		updMax(xMax, p.x);
		updMin(yMin, p.y);
		updMax(yMax, p.y);
	}
	db le = xMin, ri = xMax;
	FOR(i, 0, 74)
	{
		db m1 = le + (ri - le) / 3, m2 = ri - (ri - le) / 3;
		if (solve(m1) < solve(m2))
			le = m1;
		else
			ri = m2;
	}
	return solve((le + ri) / 2);
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout << fixed << setprecision(6);
	cin >> n >> r;
	v.resize(n);
	for (Pt& p : v)
		cin >> p.x >> p.y;
	FOR(i, 0, n)
		lines.PB({v[i], v[(i + 1) % n]});
	cout << solve() / 2 << "\n";
	return 0;
}