#include <bits/stdc++.h>
using ll = long long;
// const int N = ;

struct vector2d {
    double x, y;
    double angle() const {
        return atan2(y, x);
    }
    double dist() const {
        return sqrt(x * x + y * y);
    }
    auto &operator+=(const vector2d &v) {
        return x += v.x, y += v.y, *this;
    }
    auto &operator-=(const vector2d &v) {
        return x -= v.x, y -= v.y, *this;
    }
    friend auto operator-(vector2d a, const vector2d &b) {
        return a -= b;
    }
    friend auto operator+(vector2d a, const vector2d &b) {
        return a += b;
    }
    friend auto operator*(const vector2d &a, double b) {
        return vector2d{a.x * b, a.y * b};
    }
    friend std::ostream &operator<<(std::ostream &os, const vector2d &v) {
        return os << "(" << v.x << ", " << v.y << ")";
    }
};

struct line {
    double x, y;
    vector2d v;
};
line perpendicular_bisector(vector2d a, vector2d b) {
    return line{(a.x + b.x) / 2, (a.y + b.y) / 2, vector2d{a.y - b.y, b.x - a.x}};
}

auto pi = std::acos(-1.0);

int main() {
    std::cin.tie(0)->sync_with_stdio(0);
    int k, n;
    double s, t;
    std::cin >> n >> k;
    s = 0, t = 1;
    std::vector<vector2d> a(n);

    for (auto &[x, y] : a)
        std::cin >> x >> y;

    std::shuffle(a.begin(), a.end(), std::mt19937());

    if (s >= t) {
        std::sort(a.begin(), a.end(), [&](auto a, auto b) {
            return a.dist() < b.dist();
        });
        std::cout << std::fixed << std::setprecision(10) << t *a[k - 1].dist() << '\n';
        return 0;
    }

    double ans = 1.5e18;

    for (int i = 0; i < n; i++) {
        if (k == 1) {
            ans = std::min(ans, s * a[i].dist());
            continue;
        }

        auto check = [&](double lim) {
            std::vector<std::pair<double, int>> ve;

            for (int j = 0; j < n; j++) {
                if (i == j)
                    continue;

                auto pb = perpendicular_bisector(a[i], a[j]);
                auto calc = [&](auto d) {
                    auto p = vector2d{pb.x, pb.y} + pb.v *d;
                    return s * p.dist() + t * (p - a[i]).dist();
                };
                double l = -1e9, r = 1e9;

                for (int t = 100; t; t--) {
                    double ml = l + (r - l) / 3, mr = r - (r - l) / 3;

                    if (calc(ml) < calc(mr))
                        r = mr;
                    else
                        l = ml;
                }

                if (calc(l) > lim)
                    continue;

                double ll = -1e9, lr = l;

                for (int t = 100; t; t--) {
                    double mid = (ll + lr) / 2;

                    if (calc(mid) < lim)
                        lr = mid;
                    else
                        ll = mid;
                }

                double rl = l, rr = 1e9;

                for (int t = 100; t; t--) {
                    double mid = (rl + rr) / 2;

                    if (calc(mid) < lim)
                        rl = mid;
                    else
                        rr = mid;
                }

                // std::cerr << (vector2d{pb.x, pb.y} + pb.v * ll) << ' ' << calc(ll) << ' ' << (vector2d{pb.x, pb.y} + pb.v * rl) << ' ' << calc(rl) << '\n';
                auto al = (vector2d{pb.x, pb.y} + pb.v * ll - a[i]).angle() + pi;
                auto ar = (vector2d{pb.x, pb.y} + pb.v * rl - a[i]).angle() + pi;

                if (al > ar)
                    std::swap(al, ar);

                if (ar - al > pi)
                    ve.emplace_back(ar, 1), ve.emplace_back(al + 2 * pi, -1);
                else
                    ve.emplace_back(al, 1), ve.emplace_back(ar, -1), ve.emplace_back(al + 2 * pi, 1), ve.emplace_back(ar + 2 * pi,
                            -1);
            }

            std::sort(ve.begin(), ve.end());
            int cur = 0;

            for (auto [x, y] : ve) {
                cur += y;

                if (cur >= k - 1)
                    return 1;
            }

            return 0;
        };
        double l = 0, r = ans;

        if (!check(r))
            continue;

        for (int t = 100; t; t--) {
            double mid = (l + r) / 2;

            if (check(mid))
                r = mid;
            else
                l = mid;
        }

        ans = std::min(ans, r);
        std::cerr << i << '\n';
    }

    std::cout << std::fixed << std::setprecision(10) << ans * ans * acos(-1) << '\n';



}