#include <bits/stdc++.h>
using namespace std;
using ld = long double;
const ld eps = 1e-12;
const int N = 1010;
const ld PI = acosl(-1.0);
int n;
ld r;

struct Pld {
	ld x, y;
	Pld(ld X = 0, ld Y = 0) : x(X), y(Y) {}
	inline Pld operator+(const Pld &yy)const {
		return Pld(x + yy.x, y + yy.y);
	}
	inline Pld operator-(const Pld &yy)const {
		return Pld(x - yy.x, y - yy.y);
	}
	inline ld operator*(const Pld &yy)const {
		return x * yy.y - y * yy.x;
	}
	inline Pld operator*(const ld &yy)const {
		return Pld(x * yy, y * yy);
	}
	inline ld operator&(const Pld &yy)const {
		return x * yy.x + y * yy.y;
	}
	inline ld len() {
		return sqrtl(Pld(x, y) & Pld(x, y));
	}
	inline Pld norm() {
		return Pld(x / Pld(x, y).len(), y / Pld(x, y).len());
	}
}; Pld a[N];

struct Lld {
	Pld s, t;
	Lld(Pld S = Pld(), Pld T = Pld()) : s(S), t(T) {}
};

struct Cld {
	Pld c; ld r;
	Cld(Pld C = Pld(), ld R = 0) : c(C), r(R) {}
	bool in_circle(const Pld &x) { return (x - c).len() <= r; }
};

int sgn(ld x) {
	if(x > eps) return 1; if(x < -eps) return -1; return 0;
}
ld sqrl(ld x) { return x * x; }
ld point_to_line(Pld a, Lld b) {
	return fabsl((b.t - b.s) * (a - b.s)) / (b.t - b.s).len();
}
Pld project_to_line(Pld a, Lld b) {
	return b.s + (b.t - b.s) * (((a - b.s) & (b.t - b.s)) / ((b.t - b.s) & (b.t - b.s)));
}
bool point_on_segment(Pld a, Lld b) {
	return sgn((a - b.s) * (b.t - b.s)) == 0 && sgn((b.t - a) & (b.s - a)) <= 0;
}
vector<Pld> intersection(Cld x, Lld y) {
	if(point_to_line(x.c, y) > x.r) return {};
	ld xx = sqrtl(sqrl(x.r) - sqrl(point_to_line(x.c, y)));
	Pld a = project_to_line(x.c, y) - (y.s - y.t).norm() * xx;
	Pld b = project_to_line(x.c, y) + (y.s - y.t).norm() * xx;
	vector<Pld> vec;
	if(point_on_segment(a, y)) vec.push_back(a);
	if(point_on_segment(b, y)) vec.push_back(b);
	return vec;
}
int main() {
	ios::sync_with_stdio(0); cin.tie(nullptr);
	cout.precision(20);
	cin >> n >> r;
	for(int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
	Cld cir = Cld(Pld(0, 0), r);
	int cur = cir.in_circle(a[1]);
	vector<pair<Pld, int> > vec;
	ld ans = 0;
	for(int u = 1; u <= n; u++) {
		int v = u % n + 1;
		int nxt = cir.in_circle(a[v]);
		if(cur == nxt && nxt == 0) {
			vector<Pld> pp = intersection(cir, Lld(a[u], a[v]));
			if(pp.size() == 2) {
				if((pp[0] - a[u]).len() > (pp[1] - a[u]).len()) swap(pp[1], pp[0]);
				ans += (pp[1].x + pp[0].x) * (pp[1].y - pp[0].y) * 0.5;
				vec.push_back({pp[0], 0});
				vec.push_back({pp[1], 1});
			}
			continue;
		}
		if(cur == nxt && nxt == 1) {
			// cout << "### " << cur << " " << nxt << "\n";
			// cout << ">>> " << a[u].x << " " << a[u].y << " -> " << a[v].x << " " << a[v].y << "\n";
			ans += (a[v].x + a[u].x) * (a[v].y - a[u].y) * 0.5;
			continue;
		}
		Pld tmp = intersection(cir, Lld(a[u], a[v]))[0];
		if(cur == 1) {
			// cout << "### " << cur << " " << nxt << "\n";
			// cout << ">>> " << a[u].x << " " << a[u].y << " -> " << tmp.x << " " << tmp.y << "\n";
			ans += (tmp.x + a[u].x) * (tmp.y - a[u].y) * 0.5;
		}
		else {
			// cout << "### " << cur << " " << nxt << "\n";
			// cout << ">>> " << tmp.x << " " << tmp.y << " -> " << a[v].x << " " << a[v].y << "\n";
			ans += (a[v].x + tmp.x) * (a[v].y - tmp.y) * 0.5;
		}
		vec.push_back({tmp, cur}), cur = nxt;
	}
	sort(vec.begin(), vec.end(), [](auto x, auto y) { return atan2(x.first.y, x.first.x) < atan2(y.first.y, y.first.x); });
	for(int i = 0; i < (int)vec.size(); i++) {
		if(vec[i].second != 1) {
			assert(vec[(i + 1) % (int)vec.size()].second == 1);
			continue;
		}
		assert(vec[(i + 1) % (int)vec.size()].second == 0);
		Pld p1 = vec[i].first, p2 = vec[(i + 1) % (int)vec.size()].first;
		// cout << "arc : " << p1.x << " " << p1.y << " -> " << p2.x << " " << p2.y << "\n";
		double t1 = atan2l(p1.y, p1.x);
		double t2 = atan2l(p2.y, p2.x);
		// cout << "$$$ " << t1 << " " << t2 << "\n";
		ans += 0.5 * r * r * (0.5 * sinl(2 * t2) + t2 - 0.5 * sinl(2 * t1) - t1);
	}
	cout << ans << "\n";
	return 0;
}