#include <bits/stdc++.h>
using namespace std;
const int INF = 1.01e9;
struct pt {
  long long x, y;
  pt() {}
  pt(long long xx, long long yy) : x(xx), y(yy) {}
  pt operator+(pt A) { return pt(x + A.x, y + A.y); }
  pt operator-(pt A) { return pt(x - A.x, y - A.y); }
  pt operator*(long long k) { return pt(x * k, y * k); }
  pt operator/(long long k) {
    assert(x % k == 0 && y % k == 0);
    return pt(x / k, y / k);
  }
  long long operator*(pt A) { return x * A.y - y * A.x; }
  long long operator%(pt A) { return x * A.x + y * A.y; }
  bool operator==(pt A) { return x == A.x && y == A.y; }
  bool operator!=(pt A) { return x != A.x && y != A.y; }
  pt rotate() { return pt(-y, x); }
  long long len2() { return x * x + y * y; }
  double len() { return sqrt(x * x + y * y); }
  void read() { scanf("%lld%lld", &x, &y); }
};
vector<pt> convexHull(vector<pt> p) {
  sort((p).begin(), p.end(),
       [](pt A, pt B) { return A.x < B.x || (A.x == B.x && A.y < B.y); });
  vector<pt> st;
  for (int tt = 0; tt < 2; tt++) {
    int cur = st.size();
    for (auto A : p) {
      for (; (int)st.size() >= cur + 2 &&
             (st.back() - st[st.size() - 2]) * (A - st.back()) <= 0;
           st.pop_back())
        ;
      st.push_back(A);
    }
    st.pop_back();
    reverse((p).begin(), p.end());
  }
  return st;
}
int main() {
  int first = 1e3;
  int n, r;
  scanf("%d%d", &n, &r);
  r *= first;
  vector<pt> p(n);
  for (int i = 0; i < n; i++) {
    double x, y;
    scanf("%lf%lf", &x, &y);
    p[i] = pt(round(x * first), round(y * first));
  }
  auto ch = convexHull(p);
  int m = ch.size();
  vector<int> nxt(m);
  vector<int> prv(m);
  vector<double> val(m);
  for (int i = 0; i < m; i++) {
    nxt[i] = (i + 1) % m;
    prv[i] = (i + m - 1) % m;
  }
  cerr << "m"
       << " = " << m << endl;
  set<pair<double, int>> event;
  auto getR = [&](int id) {
    pt A = ch[prv[id]];
    pt B = ch[id];
    pt C = ch[nxt[id]];
    if (prv[id] == nxt[id]) {
      assert(prv[id] != id);
      return (A - B).len() / 2;
    }
    pt v = (A - B);
    pt u = (C - B);
    if (v % u > 0) {
      return 0.0;
    }
    double a = (A - B).len();
    double b = (B - C).len();
    double c = (A - C).len();
    double pp = (a + b + c) / 2;
    return a * b * c / (4 * sqrt(pp * (pp - a) * (pp - b) * (pp - c)));
  };
  vector<int> alive(ch.size(), 1);
  auto kill = [&](int id) {
    assert(alive[id] == 1);
    alive[id] = 0;
    int v = prv[id];
    int u = nxt[id];
    assert(alive[v] == 1);
    assert(alive[u] == 1);
    event.erase({val[v], v});
    event.erase({val[u], u});
    nxt[v] = u;
    prv[u] = v;
    val[v] = getR(v);
    val[u] = getR(u);
    event.insert({val[v], v});
    event.insert({val[u], u});
  };
  if (m <= 1) {
    puts("0.0");
    return 0;
  }
  if (m > 2) {
    for (int i = 0; i < m; i++) {
      val[i] = getR(i);
      event.insert({val[i], i});
    }
    while (true) {
      while (event.empty())
        ;
      assert(!event.empty());
      if (event.rbegin()->first <= r + 1e-9) {
        break;
      }
      auto id = event.rbegin()->second;
      event.erase(*event.rbegin());
      kill(id);
    }
  }
  int gg = -1;
  for (int i = 0; i < (int)(ch).size(); i++) {
    if (alive[i]) {
      gg = i;
      break;
    }
  }
  vector<pt> res;
  for (; alive[gg]; gg = nxt[gg]) {
    alive[gg] = 0;
    res.push_back(ch[gg]);
  }
  double answer = 0;
  for (int i = 0; i < (int)(res).size(); i++) {
    answer += res[i] * res[(i + 1) % (int)(res).size()] / 2.0;
  }
  for (int i = 0; i < (int)(res).size(); i++) {
    double len = (res[i] - res[(i + 1) % (int)(res).size()]).len();
    double c = len / 2;
    double h = sqrt(max((double)0, r * 1.0 * r - c * c));
    double ang = asin(min((double)1, c / r)) * 2;
    double add = ang * r * 1.0 * r / 2 - c * h;
    answer += add;
  }
  printf("%.17f\n", answer / first / first);
  return 0;
}
