#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#include <set>
#include <tuple>
#include <bitset>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
struct Vector {
	double x, y;
	double length() const { return std::sqrt(x * x + y * y); }
	double dot(const Vector& that) const { return x * that.x + y * that.y; }
	double cross(const Vector& that) const { return x * that.y - y * that.x; }
	Vector rotate90() const { return Vector{ -y, x }; }
	Vector flip180() const { return Vector{ -x, -y }; }
};
Vector operator*(const Vector& vec, const double scala) { return Vector{ vec.x * scala, vec.y * scala }; }
Vector operator*(const double scala, const Vector& vec) { return Vector{ vec.x * scala, vec.y * scala }; }
struct Coordinate {
	double x, y;
	double distance_from(const Coordinate& that) const { return (*this - that).length(); }
	Coordinate mid_point(const Coordinate& that) const { return Coordinate{ (x + that.x) / 2, (y + that.y) / 2 }; }
	Vector operator-(const Coordinate& that) const { return Vector{ x - that.x, y - that.y }; }
};
Coordinate operator+(const Vector& vec, const Coordinate& coordinate) { return Coordinate{ vec.x + coordinate.x, vec.y + coordinate.y }; }
Coordinate operator+(const Coordinate& coordinate, const Vector& vec) { return Coordinate{ vec.x + coordinate.x, vec.y + coordinate.y }; }
constexpr double EPS = 0.000000001;
int remove_all(const std::vector<Coordinate>& bravers, int state, const double radius, const Coordinate center) {
	for (auto i = 0; i < bravers.size(); ++i) if ((state & (1 << i)) != 0) {
		if (bravers[i].distance_from(center) <= radius + EPS) {
			state ^= 1 << i;
		}
	}
	return state;
}
bool can_defeat(const std::vector<Coordinate>& bravers, const int state, const int rest, const double radius, std::vector<std::vector<int>> &memo) {
	if (state == 0) return true;
	if (rest == 0) return false;
	if (memo[rest][state] >= 0) return memo[rest][state] == 1;
	memo[rest][state] = 0;
	for (auto i = 0; i < bravers.size(); ++i) if ((state & (1 << i)) != 0) {
		if (can_defeat(bravers, remove_all(bravers, state, radius, bravers[i]), rest - 1, radius, memo)) {
			memo[rest][state] = 1;
			return true;
		}
		for (auto j = 0; j < i; ++j) if ((state & (1 << j)) != 0 && bravers[i].distance_from(bravers[j]) <= radius * 2 + EPS && EPS < bravers[i].distance_from(bravers[j])) {
			auto mid = bravers[i].mid_point(bravers[j]);
			auto vec = bravers[i] - bravers[j];
			auto catheti = vec.rotate90() * std::sqrt(radius * radius - vec.length() * vec.length() / 4) * (1 / vec.length());
			if (can_defeat(bravers, remove_all(bravers, state, radius, mid + catheti), rest - 1, radius, memo) || can_defeat(bravers, remove_all(bravers, state, radius, mid + catheti.flip180()), rest - 1, radius, memo)) {
				memo[rest][state] = 1;
				return true;
			}
		}
	}
	return false;
}
int main() {
	int n, m; std::cin >> n >> m;
	std::vector<Coordinate> bravers(n); for (auto& braver : bravers) std::cin >> braver.x >> braver.y;
	std::vector<std::vector<int>> memo(m + 1, std::vector<int>(1 << n, -1));
	double min = 0.0;
	double max = 150000;
	while (min + 0.000001 < max) {
		auto mid = (min + max) / 2;
		for (auto& vec : memo) std::fill(vec.begin(), vec.end(), -1);
		if (can_defeat(bravers, (1 << n) - 1, m, mid, memo)) max = mid;
		else min = mid;
	}
	std::cout << std::setprecision(10) << std::fixed << max << '\n';
}



Measured memory_bytes: 3600