#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <array>
#include <bitset>
#include <assert.h>
using namespace std;

#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define ALL(c) (c).begin(), (c).end()

typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;

typedef pair<double, double> PD;

int in() { int x; scanf("%d", &x); return x; }
ll lin() { ll x; scanf("%lld", &x); return x; }

#define double long double

const double EPS = 1e-8;

double dist(PD x, PD y){
    return sqrt(pow(x.first - y.first, 2) + pow(x.second - y.second, 2));
}

double calcCircleOf2Point(PD p1, PD p2, PD p3, PD &ce){
    double x1 = p1.first, x2 = p2.first, x3 = p3.first;
    double y1 = p1.second, y2 = p2.second, y3 = p3.second;

    double ox, oy, a, b, c, d;
    double r1, r2, r3;

    a = x2 - x1 ;
    b = y2 - y1 ;
    c = x3 - x1 ;
    d = y3 - y1 ;

    if (fabs(a * d - b * c) <= EPS) return -1.0;

    ox = x1 + (d * (a * a + b * b) - b * (c * c + d * d)) / (a * d - b * c) / 2 ;
    if  (fabs(b) > EPS) {
        oy = (a * (x1 + x2 - ox - ox) + b * (y1 + y2)) / b / 2 ;
    } else {
        oy = (c * (x1 + x3 - ox - ox) + d * (y1 + y3)) / d / 2 ;
    }
    r1   = sqrt((ox - x1) * (ox - x1) + (oy - y1) * (oy - y1)) ;
    r2   = sqrt((ox - x2) * (ox - x2) + (oy - y2) * (oy - y2)) ;
    r3   = sqrt((ox - x3) * (ox - x3) + (oy - y3) * (oy - y3)) ;
    ce = PD(ox, oy);
    return (r1 + r2 + r3) / 3 ;
}

double calc(vector<PD> p){
    int n = p.size();
    if (n <= 1) return 0.0;
    if (n == 2) return dist(p[0], p[1]) / 2;

    double ret = 1e9;

    REP(i,n) REP(j,i){
        PD c((p[i].first + p[j].first) / 2, (p[i].second + p[j].second) / 2);
        double d = dist(c, p[i]);
        bool ok = true;
        REP(k,n) if (dist(c, p[k]) > d + EPS) ok = false;
        if (ok) ret = fmin(ret, d);
    }

    REP(i,n) REP(j,i) REP(k,i){
        PD c;
        double d = calcCircleOf2Point(p[i], p[j], p[k], c);
        bool ok = true;
        if (d < 0) ok = false;
        REP(l,n) if (dist(c, p[l]) > d + EPS) ok = false;
        if (ok) ret = fmin(ret, d);
    }

    return ret;
}

int main() {
    int n, m;
    cin >> n >> m;

    vector<PD> p(n);
    REP(i,n) cin >> p[i].first >> p[i].second;

    sort(ALL(p));
    p.erase(unique(ALL(p)), p.end());

    n = p.size();

    // REP(i,n){
    //     p[i].first += (rand() % 1000000) / 10000000000.0;
    //     p[i].second += (rand() % 1000000) / 10000000000.0;
    // }

    vector<double> r(1<<n);
    REP(mask,1<<n){
        vector<PD> a;
        REP(i,n) if ((mask >> i) & 1) a.push_back(p[i]);
        r[mask] = calc(a);

        // cout << mask << " " << r[mask] << endl;
    }

    vector<vector<double> > dp(1<<n, vector<double>(m+1, 1e9));
    dp[0][0] = 0;
    REP(i,m){
        REP(mask,1<<n){
            int co = (1 << n) - 1 - mask;
            for (int next = (1 << n) - 1; next >= 0; --next){
                next &= co;
                dp[mask | next][i+1] = fmin(dp[mask | next][i+1], fmax(dp[mask][i], r[next]));
            }
        }
    }

    printf("%.10Lf\n", dp[(1<<n)-1][m]);

    return 0;
}


Measured memory_bytes: 7032