#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int MAXN = 110010;
int sgn(double x) {
  if (fabs(x) < EPS) return 0;
  return x > 0 ? 1 : -1;
}
double check(double x) {
  if (sgn(x + 1) <= 0) return -1.0;
  if (sgn(x - 1) >= 0) return 1.0;
  return x;
}
double fix(double x) {
  if (sgn(x) <= 0) return 0.0;
  return x;
}
struct point {
  double x, y;
  point() : x(0), y(0) {}
  point(double a, double b) : x(a), y(b) {}
  point operator+(const point &b) const { return point(x + b.x, y + b.y); }
  point operator-(const point &b) const { return point(x - b.x, y - b.y); }
  bool operator<(const point &b) const {
    if (sgn(y - b.y) != 0) return y < b.y;
    return x < b.x;
  }
  double operator^(const point &b) const { return x * b.x + y * b.y; }
  double operator*(const point &b) const { return x * b.y - y * b.x; }
  double dis(const point &b) {
    return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
  }
};
point p[MAXN], tp[MAXN], ans[MAXN], tans[MAXN];
double num[MAXN], R;
int num2[MAXN];
int l[MAXN], r[MAXN];
bool next(point a, point b, point c) { return (sgn((b - c) * (a - c)) > 0); }
int GrahamScan(point *p, int n) {
  p[n] = p[0];
  if (n == 1 || n == 2) return n;
  sort(p, p + n);
  int j = -1;
  for (int i = 0; i < n; i++) {
    while (j >= 1 && !next(p[i], tp[j], tp[j - 1])) j--;
    tp[++j] = p[i];
  }
  int top = j;
  for (int i = n - 2; i >= 0; i--) {
    while (j >= top + 1 && !next(p[i], tp[j], tp[j - 1])) j--;
    tp[++j] = p[i];
  }
  for (int i = 0; i < j; i++) p[i] = tp[i];
  p[j] = p[0];
  return j;
}
struct node {
  int id;
  bool operator<(const node &b) const {
    if (sgn(num[id] - num[b.id]) != 0) return num[id] > num[b.id];
    double d1, d2;
    d1 = p[l[id]].dis(p[r[id]]);
    d2 = p[l[b.id]].dis(p[r[b.id]]);
    if (sgn(d1 - d2) != 0) return d1 < d2;
    return id > b.id;
  }
};
double cal(int id) {
  if (l[id] == id || r[id] == id || l[id] == r[id]) return 0;
  double d1, d2, d3;
  d1 = p[l[id]].dis(p[id]);
  d2 = p[id].dis(p[r[id]]);
  d3 = p[l[id]].dis(p[r[id]]);
  double num = fabs((p[l[id]] - p[id]) * (p[r[id]] - p[id]));
  return (d1 * d2) / (2 * num) * d3;
}
double getans(point *p, int n) {
  p[n] = p[0];
  double ans = 0;
  for (int i = 0; i < n; i++) ans += p[i] * p[i + 1];
  ans = fabs(ans) / 2.0;
  for (int i = 0; i < n; i++) {
    double dis = (p[i + 1].x - p[i].x) * (p[i + 1].x - p[i].x) +
                 (p[i + 1].y - p[i].y) * (p[i + 1].y - p[i].y);
    double coss = check((dis - 2 * R * R) / (-2 * R * R));
    double sinn = sqrt(fix(1 - coss * coss));
    ans += 0.5 * R * R * (acos(coss) - sinn);
  }
  return ans;
}
set<node> ss;
set<node>::iterator pos;
int main() {
  int n;
  while (scanf("%d%lf", &n, &R) == 2) {
    int nn = n;
    for (int i = 0; i < n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
    n = GrahamScan(p, n);
    for (int i = 0; i < n; i++) {
      l[i] = (i == 0 ? n - 1 : i - 1);
      r[i] = (i == n - 1 ? 0 : i + 1);
    }
    ss.clear();
    int size = 0;
    for (int i = 0; i < n; i++) {
      node next;
      next.id = i;
      num[i] = cal(i);
      ss.insert(next);
      size++;
    }
    node next;
    while (size > 3) {
      pos = ss.begin();
      if (sgn(num[pos->id] - R) <= 0) break;
      int ll = l[pos->id], rr = r[pos->id];
      ss.erase(*pos);
      next.id = ll;
      ss.erase(next);
      next.id = rr;
      ss.erase(next);
      r[ll] = rr;
      l[rr] = ll;
      num[ll] = cal(ll);
      num[rr] = cal(rr);
      node next;
      next.id = ll;
      ss.insert(next);
      next.id = rr;
      ss.insert(next);
      size--;
    }
    pos = ss.begin();
    int cnt = 0, now = pos->id;
    ans[cnt++] = p[now];
    now = r[now];
    while (now != pos->id) {
      ans[cnt++] = p[now];
      now = r[now];
    }
    ans[cnt] = ans[0];
    ans[cnt + 1] = ans[1];
    pos = ss.begin();
    if (size != 3)
      printf("%.15f\n", getans(ans, cnt));
    else {
      int tcnt = 0;
      for (int i = 1; i <= cnt; i++) {
        double d1, d2, d3;
        d1 = ans[i - 1].dis(ans[i]), d2 = ans[i + 1].dis(ans[i]),
        d3 = ans[i - 1].dis(ans[i + 1]);
        if (sgn(d1 * d1 + d2 * d2 - d3 * d3) >= 0) tans[tcnt++] = ans[i];
      }
      tans[tcnt] = tans[0];
      printf("%.15f\n", getans(tans, tcnt));
    }
  }
  return 0;
}
