#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


using Double = long double;
const Double EPS = 1e-10L;
const Double INF = 1e+10L;
const Double PI = acos(-1.0L);
inline int sig(Double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline Double sq(Double r) { return r * r; }

struct Pt {
  Double x, y;
  Pt() {}
  Pt(Double x_, Double y_) : x(x_), y(y_) {}
  Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
  Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
  Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
  Pt operator/(const Pt &a) const { const Double d2 = a.abs2(); return Pt((x * a.x + y * a.y) / d2, (y * a.x - x * a.y) / d2); }
  Pt operator+() const { return Pt(+x, +y); }
  Pt operator-() const { return Pt(-x, -y); }
  Pt operator*(const Double &k) const { return Pt(x * k, y * k); }
  Pt operator/(const Double &k) const { return Pt(x / k, y / k); }
  friend Pt operator*(const Double &k, const Pt &a) { return Pt(k * a.x, k * a.y); }
  Pt &operator+=(const Pt &a) { x += a.x; y += a.y; return *this; }
  Pt &operator-=(const Pt &a) { x -= a.x; y -= a.y; return *this; }
  Pt &operator*=(const Pt &a) { return *this = *this * a; }
  Pt &operator/=(const Pt &a) { return *this = *this / a; }
  Pt &operator*=(const Double &k) { x *= k; y *= k; return *this; }
  Pt &operator/=(const Double &k) { x /= k; y /= k; return *this; }
  Double abs() const { return sqrt(x * x + y * y); }
  Double abs2() const { return x * x + y * y; }
  Double arg() const { return atan2(y, x); }
  Double dot(const Pt &a) const { return x * a.x + y * a.y; }
  Double det(const Pt &a) const { return x * a.y - y * a.x; }
  friend ostream &operator<<(ostream &os, const Pt &a) { os << "(" << a.x << ", " << a.y << ")"; return os; }
  bool operator<(const Pt &a) const { return (x != a.x) ? (x < a.x) : (y < a.y); }
};
inline Double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }

Pt proj(const Pt &a, const Pt &b) { return a * a.dot(b) / a.abs2(); }
Pt perp(const Pt &a, const Pt &b, const Pt &c) { return a + proj(b - a, c - a); }
Pt refl(const Pt &a, const Pt &b, const Pt &c) { return perp(a, b, c) * 2 - c; }

vector<Pt> convexHull(vector<Pt> ps) {
  const int n = ps.size();
  sort(ps.begin(), ps.end());
  vector<Pt> qs;
  for (int i = 0; i < n; qs.push_back(ps[i++]))
    for (; qs.size() > 1 && sig(tri(qs[qs.size() - 2], qs[qs.size() - 1], ps[i])) <= 0; qs.pop_back()) {}
  const int r = qs.size();
  for (int i = (int)ps.size() - 2; i >= 0; qs.push_back(ps[i--]))
    for (; (int)qs.size() > r && sig(tri(qs[qs.size() - 2], qs[qs.size() - 1], ps[i])) <= 0; qs.pop_back()) {}
  if (qs.size() > 1) qs.pop_back();
  return qs;
}

vector<Pt> pCL(const Pt &a, Double r, const Pt &b, const Pt &c) {
  const Pt h = perp(b, c, a);
  const Double d = (h - a).abs();
  if (sig(d - r) <= 0) {
    const Double y = sqrt(max(r * r - d * d, (Double)0));
    const Pt e = (c - b) / (c - b).abs();
    return { h - e * y, h + e * y };
  } else {
    return {};
  }
}


Double mod(Double t) {
  for (; t < 1; t += 2 * PI) {}
  for (; t >= 1 + 2 * PI; t -= 2 * PI) {}
  return t;
}

int N;
Double R;
vector<Pt> P;

Pt cir(Double t) {
  return Pt(R * cos(t), R * sin(t));
}

int main() {
  for (; ~scanf("%d%Lf", &N, &R); ) {
    P.resize(N);
    for (int i = 0; i < N; ++i) {
      int x, y;
      scanf("%d%d", &x, &y);
      P[i] = Pt(x, y);
    }
    
    P = convexHull(P);
    N = P.size();
// cerr<<"P = "<<P<<endl;
    
    vector<Double> sums(N + 1, 0.0);
    for (int i = 0; i < N; ++i) {
      sums[i + 1] = sums[i] + P[i].det(P[(i + 1) % N]);
    }
    Double ans = sums[N];
    if (N >= 2) {
      vector<int> ini(N, 0);
      vector<Double> ts{1, 1 + 2 * PI};
      for (int i = 0; i < N; ++i) {
        const auto res = pCL(Pt(0, 0), R, P[i], P[(i + 1) % N]);
        assert(res.size() == 2);
        const Double t0 = mod(res[0].arg());
        const Double t1 = mod(res[1].arg());
// cerr<<res<<" "<<t0<<" "<<t1<<endl;
        if (t0 > t1) {
          ini[i] = 1;
        }
        ts.push_back(t0);
        ts.push_back(t1);
      }
      sort(ts.begin(), ts.end());
// cerr<<"ini = "<<ini<<endl;
// cerr<<"ts = "<<ts<<endl;
      
      // visible: edges [l, r)
      int l = 0, r = 0;
      for (int i = 1; i < N; ++i) {
        if (!ini[i - 1] && ini[i]) l = i;
        if (ini[i - 1] && !ini[i]) r = i;
      }
      for (int h = 0; h < (int)ts.size() - 1; ++h) {
        const Double t0 = ts[h];
        const Double t1 = ts[h + 1];
        const Double tMid = (t0 + t1) / 2;
        const Pt p = cir(tMid);
        for (; tri(P[l], P[(l + 1) % N], p) > 0; l = (l + 1) % N) {}
        for (; tri(P[r], P[(r + 1) % N], p) < 0; r = (r + 1) % N) {}
// cerr<<"["<<t0<<", "<<t1<<"] "<<p<<" ["<<l<<", "<<r<<")"<<endl;
        Double mx = 0.0;
        chmax(mx, tri(P[r], P[l], cir(t0)));
        chmax(mx, tri(P[r], P[l], cir(t1)));
        // parallel to P[l]P[r]
        Double t2 = mod((P[r] - P[l]).arg() - PI / 2);
        for (int s = -1; s <= +1; ++s) {
          const Double t = t2 + s * PI;
          if (t0 <= t && t <= t1) {
// cerr<<"  t = "<<t<<", cir(t) = "<<cir(t)<<endl;
            chmax(mx, tri(P[r], P[l], cir(t)));
          }
        }
        Double here = sums[N];
        if (l < r) {
          here -= (sums[r] - sums[l]);
        } else {
          here -= (sums[r] + (sums[N] - sums[l]));
        }
        here += P[l].det(P[r]);
        here += mx;
// cerr<<"  mx = "<<mx<<", here = "<<here<<endl;
        chmax(ans, here);
      }
      
    }
    ans /= 2;
    printf("%.12Lf\n", ans);
  }
  return 0;
}