#include <bits/stdc++.h>

using i64 = long long;

struct Point {
    double x;
    double y;
    Point() : x{0}, y{0} {}
    Point(double x_, double y_) : x{x_}, y{y_} {}
};

double dot(Point a, Point b) {
    return a.x * b.x + a.y * b.y;
}

double cross(Point a, Point b) {
    return a.x * b.y - a.y * b.x;
}

Point operator+(Point a, Point b) {
    return Point(a.x + b.x, a.y + b.y);
}

Point operator-(Point a, Point b) {
    return Point(a.x - b.x, a.y - b.y);
}

const double Pi = std::acos(-1.0);

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int N, R;
    std::cin >> N >> R;

    std::cout << std::fixed << std::setprecision(10);
    if (N == 1) {
        std::cout << 0.0 << "\n";
        return 0;
    }

    std::vector<Point> p(N);
    for (int i = 0; i < N; i++) {
        int x, y;
        std::cin >> x >> y;
        p[i] = Point(x, y);
    }

    std::sort(p.begin(), p.end(),
        [&](auto a, auto b) {
            return a.x < b.x && (a.x == b.x && a.y < b.y);
        });
    
    std::vector<Point> hi, lo;
    for (auto p : p) {
        while (hi.size() > 1 && cross(hi.back() - hi[hi.size() - 2], p - hi.back()) >= 0) {
            hi.pop_back();
        }
        hi.push_back(p);
        while (lo.size() > 1 && cross(lo.back() - lo[lo.size() - 2], p - lo.back()) <= 0) {
            lo.pop_back();
        }
        lo.push_back(p);
    }
    lo.pop_back();
    lo.insert(lo.end(), hi.rbegin(), hi.rend() - 1);
    p = lo;
    N = p.size();

    double ans = 0;
    std::vector<int> sum(N + 1);
    for (int i = 0; i < N; i++) {
        sum[i + 1] = sum[i] + cross(p[i], p[(i + 1) % N]);
    }

    ans = sum[N];

    std::vector<double> cand;
    for (int i = 0; i < N; i++) {
        Point a = p[i], b = p[(i + 1) % N];
        if (cross(a, b) < 0) {
            std::swap(a, b);
        }
        double area = cross(a, b);
        double ab = std::sqrt(dot(a - b, a - b));
        double d = area / ab;
        double ang = std::asin(d / R);
        double oa = std::sqrt(dot(a, a));
        double ob = std::sqrt(dot(b, b));
        double angb = std::acos((ab * ab + ob * ob - oa * oa) / 2 / ab / ob);
        double t1 = std::atan2(b.y, b.x) + (angb - ang);
        double t2 = t1 - (Pi - 2 * ang);
        cand.push_back(t1);
        cand.push_back(t2);
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (i != j) {
                cand.push_back(std::atan2(p[j].x - p[i].x, p[i].y - p[j].y));
            }
        }
    }

    std::sort(cand.begin(), cand.end());
    int i = 0, j = 0;
    for (auto t : cand) {
        Point q = Point(R * std::cos(t), R * std::sin(t));
        while (cross(p[i] - q, p[(i + 1) % N] - p[i]) < 0) {
            i = (i + 1) % N;
        }
        while (cross(p[i] - q, p[(i - 1 + N) % N] - p[i]) < 0) {
            i = (i - 1 + N) % N;
        }
        while (cross(p[j] - q, p[(j + 1) % N] - p[j]) > 0) {
            j = (j + 1) % N;
        }
        while (cross(p[j] - q, p[(j - 1 + N) % N] - p[j]) > 0) {
            j = (j - 1 + N) % N;
        }
        double res = sum[N];
        if (i > j) {
            res -= sum[i] - sum[j];
        } else {
            res = sum[j] - sum[i];
        }
        res += cross(p[j], q);
        res += cross(q, p[i]);
        ans = std::max(ans, res);
    }

    ans /= 2;
    std::cout << ans << "\n";

    return 0;
}