#include<iostream>
#include<complex>
#include<queue>
#include<algorithm>
#include<cstdio>

using namespace std;

#define rep(i, n) for (int i = 0; i < int(n); ++i)

#define X real()
#define Y imag()

typedef long double D;
typedef complex<D> P;
struct L{P a, b;};
typedef vector<P> Pol;

const D EPS = 1e-8;
const D PI = acos(-1);

inline int sig(const D &a, const D &b = 0) {return a < b - EPS ? -1 : a > b + EPS ? 1 : 0;}
inline bool near(const P &a, const P &b) {return !sig(norm(a - b));}
namespace std {
  inline bool operator<(const P &a, const P &b) {return sig(a.X, b.X) ? a.X < b.X : a.Y < b.Y;}
  inline bool operator<(const L &a, const L &b) {return !near(a.a, b.a) ? a.a < b.a : a.b < b.b;}
}

inline D det(const P &a, const P &b) {return a.X * b.Y - a.Y * b.X;}

inline P vec(const L &a) {return a.b - a.a;}

enum CCW{FRONT = 1, RIGHT = 2, BACK = 4, LEFT = 8, ON = 16};
inline int ccw(const P &a, const P &b, const P &c) {
  if (near(a, c) || near(b, c)) return ON;
  int s = sig(det(b - a, c - a));
  if (s) return s > 0 ? LEFT : RIGHT;
  return (a < b) == (b < c) ? FRONT : (c < a) == (a < b) ? BACK : ON;
}

inline bool iLLs(const L &a, const L &b) {return sig(det(vec(a), vec(b)));}
inline bool iLSs(const L &a, const L &b) {return sig(det(vec(a), b.a - a.a)) * sig(det(vec(a), b.b - a.a)) < 0;}
inline bool iSS(const L &a, const L &b) {
  int cwa = ccw(a.a, a.b, b.a) | ccw(a.a, a.b, b.b);
  int cwb = ccw(b.a, b.b, a.a) | ccw(b.a, b.b, a.b);
  return ((cwa | cwb) & ON) || ((cwa & cwb) == (LEFT | RIGHT));
}

inline P pLL(const L &a, const L &b) {return a.a + vec(a) * (det(vec(b), b.a - a.a) / det(vec(b), vec(a)));}

inline D dmPP(const P &a, const P &b) {return abs(a.X - b.X) + abs(a.Y - b.Y);}
inline D dmSP(const L &s, const P &p) {
  D res = min(dmPP(s.a, p), dmPP(s.b, p));
  L l = {p, p + P(1, 0)};
  if (iLSs(l, s)) res = min(res, dmPP(p, pLL(l, s)));
  l = (L){p, p + P(0, 1)};
  if (iLSs(l, s)) res = min(res, dmPP(p, pLL(l, s)));
  return res;
}
inline D dmSS(const L &a, const L &b) {return iSS(a, b) ? 0 : min(min(dmSP(a, b.a), dmSP(a, b.b)), min(dmSP(b, a.a), dmSP(b, a.b)));}

inline int sGP(const Pol &pol, const P &p) {
  int side = -1;
  rep (i, pol.size()) {
    P p0 = pol[i] - p, p1 = pol[(i + 1) % pol.size()] - p;
    if (ccw(p0, p1, 0) == ON) return 0;
    if (p0.Y > p1.Y) swap(p0, p1);
    if (sig(p0.Y) <= 0 && 0 < sig(p1.Y) && sig(det(p0, p1)) > 0) side *= -1;
  }
  return side;
}

inline void merge(vector<L> &s) {
  rep (i, s.size()) if (s[i].b < s[i].a) swap(s[i].a, s[i].b);
  sort(s.begin(), s.end());
  rep (i, s.size()) rep (j, i) if (iSS(s[i], s[j]) && !iLLs(s[i], s[j])) {
    s[j].b = max(s[i].b, s[j].b);
    s.erase(s.begin() + i--);
    break;
  }
}

inline vector<vector<int> > sArr(vector<L> s, vector<P> &vp) {
  merge(s);
  rep (i, s.size()) {
    vp.push_back(s[i].a);
    vp.push_back(s[i].b);
  }
  rep (i, s.size()) rep (j, i) if (iSS(s[i], s[j])) vp.push_back(pLL(s[i], s[j]));
  sort(vp.begin(), vp.end());
  vp.erase(unique(vp.begin(), vp.end(), near), vp.end());
  vector<vector<int> > g(vp.size());
  rep (i, s.size()) {
    vector<pair<D, int> > v;
    rep (j, vp.size()) if (ccw(s[i].a, s[i].b, vp[j]) == ON) {
      v.push_back(make_pair(norm(vp[j] - s[i].a), j));
    }
    sort(v.begin(), v.end());
    rep (j, v.size() - 1) {
      g[v[j + 1].second].push_back(v[j].second);
      g[v[j].second].push_back(v[j + 1].second);
    }
  }
  return g;
}

int main() {
  while (true) {
    int n;
    D r;
    cin >> n >> r;
    if (n == 0) break;
    Pol pol(n);
    rep (i, n) cin >> pol[i].X >> pol[i].Y;
    vector<L> vs;
    rep (i, n) rep (j, 4) vs.push_back((L){pol[i] + polar(r, j * PI / 2), pol[(i + 1) % n] + polar(r, j * PI / 2)});
    rep (i, n) rep (j, 4) vs.push_back((L){pol[i] + polar(r, j * PI / 2), pol[i] + polar(r, (j + 1) * PI / 2)});
    vector<P> vp;
    vector<vector<int> > g = sArr(vs, vp);
    D res = 0;
    rep (i, g.size()) rep (j, g[i].size()) {
      L l = (L){vp[i], vp[g[i][j]]};
      rep (i, n) if (sig(r, dmSP((L){pol[i], pol[(i + 1) % n]}, (l.a + l.b) / (D)2)) > 0) goto next;
      if (sGP(pol, l.a) < 0) continue;
      res += abs(vec(l));
    next:;
    }
    printf("%.12Lf\n", res / 2);
  }
  return 0;
}

Measured memory_bytes: 1808