#include <bits/stdc++.h>
using namespace std;

namespace {

using llf = long double;
using PTF = complex<llf>;

const llf eps = 1e-9;

int sgn(llf x) {
    if (abs(x) < eps)
        return 0;
    return (x > 0) - (x < 0);
}

llf cross(PTF a, PTF b) {
    return imag(conj(a) * b);
}
llf dot(PTF a, PTF b) {
    return real(conj(a) * b);
}
PTF project(PTF p, PTF q) {
    return dot(p, q) * q / dot(q, q);
}

struct L {
    PTF st, ed, dir;
    L(PTF s, PTF e)
        : st(s), ed(e), dir(e - s) {}
    static bool valid(llf, llf) { return true; }
    vector<PTF> ends() { return {}; }
};

struct S {
    PTF st, dir;
    S(PTF s, PTF e) : st(s), dir(e - s) {}
    static bool valid(llf p, llf q) {
        if (sgn(q) < 0) q = -q, p = -p;
        return 0 <= p and p <= q;
    }
    vector<PTF> ends() { return {}; }
};

template <typename T> bool isInter(T A, PTF P) {
    if (abs(A.dir) < eps) return abs(P - A.st) < eps;
    return sgn(cross(P - A.st, A.dir)) == 0
        and T::valid(dot(P - A.st, A.dir), norm(A.dir));
}

template <typename U, typename V>
bool isInter(U A, V B) {
    if (sgn(cross(A.dir, B.dir)) == 0) {
        return false;
    }
    PTF D = B.st - A.st;
    llf C = cross(A.dir, B.dir);
    return U::valid(cross(D, B.dir), C) and V::valid(cross(D, A.dir), C);
}

template <typename U, typename V>
PTF intersect(const U &A, const V &B) {
    llf t = cross(B.st - A.st, B.dir) / cross(A.dir, B.dir);
    return A.st + t * A.dir;
}

vector<PTF> interCircle(const L &l, const PTF &c, const llf r) {
    PTF ft = l.st + project(c - l.st, l.dir);

    llf dis = abs(c - ft);
    if (abs(dis - r) < eps) {
        return {ft};
    }
    if (dis > r + eps) return {};
    // cerr << "here " << l.dir << ' ' << ft << ' ' << r*r-dis*dis << endl;
    PTF vec = l.dir * sqrt(max<llf>(0, r * r - dis * dis)) / abs(l.dir);
    return {ft + vec, ft - vec};
};


optional<pair<llf, llf>> sausageBorder(PTF p1, PTF p2, llf d) {
    if (sgn(imag(p1 - p2)) == 0) {
        if (abs(imag(p1)) + eps < d) {
            return minmax(real(p1), real(p2));
        }
        return {};
    }
    if (sgn(real(p1 - p2)) == 0) {
        pair<llf, llf> r = minmax(imag(p1), imag(p2));
        if (r.first + eps < 0 and eps < r.second)
            return pair{real(p1) - d, real(p1) + d};
        return {};
    }

    auto v = p1 - p2;
    v = {-imag(v), real(v)};
    v *=  d / abs(v);
    auto s1 = S(p1 - v, p2 - v);
    auto s2 = S(p1 + v, p2 + v);
    auto s3 = S(p1 - v, p1 + v);
    auto s4 = S(p2 - v, p2 + v);

    const L xl = L({0, 0}, {1, 0});
    vector<PTF> vs;
    for (auto s : vector{s1, s2, s3, s4}) {
        if (isInter(xl, s))
            vs.push_back(intersect(xl, s));
    }
    for (auto p : {p1 - v, p1 + v, p2 - v, p2 + v}) {
        if (sgn(imag(p)) == 0)
            vs.push_back(p);
    }
    if (vs.size() == 2)
        return minmax(real(vs[0]), real(vs[1]));
    assert (vs.size() < 2);
    return {};
}

optional<pair<llf, llf>> circleBorder(PTF p1, llf d) {
    auto v = interCircle(L({0, 0}, {1, 0}), p1, d);
    if (v.size() != 2) return {};
    return minmax(real(v[0]), real(v[1]));
}

optional<pair<llf, llf>> sausage_inter(PTF p1, PTF p2, llf d) {
    optional<pair<llf, llf>> ans = {};
    auto upd = [&ans](optional<pair<llf, llf>> x) {
        if (not ans) ans = x;
        else {
            ans->first = min(ans->first, x->first);
            ans->second = max(ans->second, x->second);
        }
    };
    if (auto x = circleBorder(p1, d)) 
        upd(x);
    if (auto x = circleBorder(p2, d)) 
        upd(x);
    if (auto x = sausageBorder(p1, p2, d))
        upd(x);
    
    return ans;
}

} // namespace

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, r;
    cin >> n >> r;
    
    vector<PTF> pt(n);
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        pt[i] = {x, y};
    }

    vector<pair<llf, llf>> segs;
    for (int i = 0; i < n; i++) {
        if (auto x = sausage_inter(pt[i], pt[(i + 1) % n], r)) {
            cerr << "sausage seg " << x->first << ' ' << x->second << endl;
            segs.emplace_back(x->first, x->second);
        }
    }

    L xaxis_shifted(PTF{0, 0.5}, PTF{1, 0.5});

    vector<llf> xs;

    for (int i = 0; i < n; i++) {
        S seg(pt[i], pt[(i + 1) % n]);

        if (isInter(xaxis_shifted, seg)) {
            auto ip = intersect(xaxis_shifted, seg);
            // cerr << "ip = " << ip << endl;
            llf x = real(ip);
            xs.push_back(x);
        }
    }

    assert (xs.size() % 2 == 0);

    sort(xs.begin(), xs.end());

    vector<tuple<llf,int,int>> evt;

    for (auto [l, r]: segs) {
        evt.emplace_back(l, 0, 1);
        evt.emplace_back(r, 0, -1);
    }


    llf D = sqrt(1LL * r * r - 0.5 * 0.5);
    // cerr << "D = " << D << endl;
    for (int i = 0; i + 1 < xs.size(); i += 2) {
        llf A = xs[i], B = xs[i + 1];
        if (A + D <= B - D) {
            llf L = A + D;
            llf R = B - D;
            // segs.emplace_back(A + r, B - r);
            evt.emplace_back(L, 1, 0);
            evt.emplace_back(R, -1, 0);
            // cerr << "other seg " << L << ' ' << R << endl;
        }
    }

    sort(evt.begin(), evt.end());

    int cnt = 0;
    int cnt2 = 0;
    llf ans = 0;

    for (int i = 0, j = 0; i < evt.size(); i = j) {
        for (j = i; j < evt.size(); j++) {
            if (get<0>(evt[j]) != get<0>(evt[i]))
                break;
            auto [_, a, b] = evt[j];
            cnt += a;
            cnt2 += b;
        }

        if (cnt > 0 && cnt2 == 0) {
            assert (j != evt.size());
            ans += get<0>(evt[j]) - get<0>(evt[i]);
        }
    }

    cout << fixed << setprecision(20);
    cout << ans << '\n';

    return 0;
}