#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
const double pi = acos(-1);
const double eps = 1e-10;
int n;
double r;
struct vec {
  double x, y;
  bool operator<(const vec &p) const { return x < p.x; }
  vec operator%(const vec &p) {
    vec ans;
    ans.x = x * p.x - y * p.y;
    ans.y = x * p.y + y * p.x;
    return ans;
  }
  vec operator-(const vec &p) {
    vec ans;
    ans.x = x - p.x;
    ans.y = y - p.y;
    return ans;
  }
  double operator*(const vec &p) { return x * p.y - y * p.x; }
} a[N + 10];
namespace Rand {
int Rand_small() { return rand() % 32768; }
int Rand_big() {
  int x = Rand_small();
  int y = Rand_small();
  return x * 32768 + y;
}
vec Rand() {
  vec now;
  now.x = Rand_big() * 1.0 / 1073741823;
  now.y = 1 - now.x * now.x;
  while (now.y < 0) now.y += eps;
  now.y = sqrt(now.y);
  return now;
}
}  // namespace Rand
namespace Pre {
int ans[N + 10], tot;
int q[N + 10], cnt;
bool ok1(vec a, vec b, vec c) { return (c - a) * (b - a) > eps; }
bool ok2(vec a, vec b, vec c) { return (c - a) * (b - a) < -eps; }
void Build() {
  tot = cnt = 0;
  for (int i = 1; i <= n; i++) {
    if (cnt < 2) {
      q[++cnt] = i;
      continue;
    }
    while (cnt > 1 && !ok1(a[q[cnt - 1]], a[q[cnt]], a[i])) cnt--;
    q[++cnt] = i;
  }
  for (int i = 1; i <= cnt; i++) ans[++tot] = q[i];
  cnt = 0;
  for (int i = 1; i <= n; i++) {
    if (cnt < 2) {
      q[++cnt] = i;
      continue;
    }
    while (cnt > 1 && !ok2(a[q[cnt - 1]], a[q[cnt]], a[i])) cnt--;
    q[++cnt] = i;
  }
  for (int i = cnt - 1; i >= 2; i--) ans[++tot] = q[i];
}
}  // namespace Pre
namespace Solve {
priority_queue<pair<double, int> > q;
double sqr(double x) { return x * x; }
double Dist(vec A, vec B) {
  double now = sqr(A.x - B.x) + sqr(A.y - B.y);
  while (now < 0) now += eps;
  return sqrt(now);
}
double Calc_r(vec A, vec B, vec C) {
  double a = Dist(B, C);
  double b = Dist(A, C);
  double c = Dist(A, B);
  if (a < eps) return b / 2;
  if (b < eps || c < eps) return a / 2;
  double nowcos = (b * b + c * c - a * a) / 2 / b / c;
  double nowsin = 1 - nowcos * nowcos;
  while (nowsin < 0) nowsin += eps;
  nowsin = sqrt(nowsin);
  return a / nowsin / 2;
}
int nxt[N + 10], lst[N + 10], l[N + 10], vis[N + 10];
double nowv[N + 10];
double Calc(double x) {
  double now = r * r - x * x / 4;
  while (now < 0) now += eps;
  double now2 = x / 2 / r;
  while (now2 > 1) now2 -= eps;
  while (now2 < 0) now2 += eps;
  return r * r * asin(now2) - 0.5 * x * sqrt(now);
}
double Calc_a(double x, double r) {
  double now = x / 2 / r;
  while (now > 1) now -= eps;
  while (now < 0) now += eps;
  return asin(x / 2 / r);
}
void work() {
  int n = Pre::tot;
  for (int i = 1; i <= n; i++) {
    nxt[i] = i + 1;
    lst[i] = i - 1;
  }
  nxt[n] = 1;
  lst[1] = n;
  for (int i = 1; i <= n; i++) {
    vis[i] = 0;
    int j = nxt[i];
    int k = nxt[j];
    double nowr = Calc_r(a[Pre::ans[i]], a[Pre::ans[j]], a[Pre::ans[k]]);
    q.push(make_pair(nowr, i));
    nowv[i] = nowr;
  }
  while (!q.empty()) {
    pair<double, int> pii = q.top();
    q.pop();
    if (pii.first < r + eps) break;
    int k = pii.second;
    if (vis[k] || abs(nowv[k] - pii.first) > eps) continue;
    double now1 = Calc_a(Dist(a[Pre::ans[k]], a[Pre::ans[nxt[k]]]), pii.first);
    double now2 =
        Calc_a(Dist(a[Pre::ans[nxt[k]]], a[Pre::ans[nxt[nxt[k]]]]), pii.first);
    double now3 =
        Calc_a(Dist(a[Pre::ans[k]], a[Pre::ans[nxt[nxt[k]]]]), pii.first);
    if (abs(now1 + now2 - now3) > abs(abs(now1 - now2) - now3)) continue;
    vis[nxt[k]] = 1;
    nxt[k] = nxt[nxt[k]];
    lst[nxt[k]] = k;
    double nowr =
        Calc_r(a[Pre::ans[k]], a[Pre::ans[nxt[k]]], a[Pre::ans[nxt[nxt[k]]]]);
    nowv[k] = nowr;
    q.push(make_pair(nowr, k));
    nowr = Calc_r(a[Pre::ans[lst[k]]], a[Pre::ans[k]], a[Pre::ans[nxt[k]]]);
    nowv[lst[k]] = nowr;
    q.push(make_pair(nowr, lst[k]));
  }
  vec now;
  now.x = now.y = -1e5;
  double ans = 0;
  for (int i = 1; i <= n; i++) {
    if (vis[i]) continue;
    int j = nxt[i];
    if (i == j) {
      ans += pi * r * r;
      continue;
    }
    ans += (a[Pre::ans[j]] - now) * (a[Pre::ans[i]] - now) / 2;
    ans += Calc(Dist(a[Pre::ans[j]], a[Pre::ans[i]]));
  }
  printf("%.10lf\n", ans);
}
}  // namespace Solve
int main() {
  srand(2333);
  scanf("%d%lf", &n, &r);
  if (n == 1) {
    printf("0\n");
    return 0;
  }
  for (int i = 1; i <= n; i++) scanf("%lf%lf", &a[i].x, &a[i].y);
  while (1) {
    vec rot = Rand::Rand();
    for (int i = 1; i <= n; i++) a[i] = a[i] % rot;
    sort(a + 1, a + n + 1);
    bool judge = 1;
    for (int i = 1; i < n; i++)
      if (abs(a[i].x - a[i + 1].x) < eps) judge = 0;
    if (judge) break;
  }
  Pre::Build();
  Solve::work();
  return 0;
}
