#include <bits/stdc++.h>

typedef long double T;
const T eps = 1e-7;

using namespace std;

struct pt
{
	T x, y;
	pt (T x = 0.0, T y = 0.0) : x(x), y(y) { }
	pt operator+(const pt &z) const { return pt(x + z.x, y + z.y); }
	pt operator-(const pt &z) const { return pt(x - z.x, y - z.y); }
	pt operator*(const T k) const { return pt(x * k, y * k); }
	pt operator/(const T k) const { return pt(x / k, y / k); }
	bool operator==(const pt &z) const
	{
		return x == z.x && y == z.y;
	}
	bool operator!=(const pt &z) const
	{
		return x != z.x || y != z.y;
	}
};
pt operator*(const T k, const pt &z) { return pt(z.x * k, z.y * k); }
pt operator/(const T k, const pt &z) { return pt(z.x / k, z.y / k); }

inline int dcmp(const T x)
{
	if (x > eps) return 1;
	if (x < -eps) return -1;
	return 0;
}
std::istream& operator>>(std::istream &inf, pt &p)
{
	return inf >> p.x >> p.y;
}

std::ostream& operator<<(std::ostream &ouf, const pt &p)
{
	return ouf << p.x << " " << p.y;
}

inline T dot(const pt &a, const pt &b) 
{
	return a.x * b.x + a.y * b.y;
}
inline T cross(const pt &a, const pt &b)
{
	return a.x * b.y - a.y * b.x;
}
inline pt midpoint(const pt &a, const pt &b)
{
	return (a + b) / 2.0;
}
inline T sq(const pt &a)
{
	return a.x * a.x + a.y * a.y;
}
inline T abs(const pt &a)
{
	return sqrtl(sq(a));
}
inline pt perp(const pt &p)
{
	return pt(-p.y, p.x);
}

struct ln
{
	pt v; T c;
	ln(pt v, T c) : v(v), c(c) { } // direction vector + offset
	ln(T a, T b, T c) : v({b, -a}), c(c) { } // ax + by = c
	ln(pt p, pt q) : v(q - p), c(cross(v, p)) { } // p, q
	T side(const pt &p) const
	{
		return cross(v, p) - c;
	}
	T dist(const pt &p) const
	{
		return abs(side(p)) / abs(v);
	}
	T sqDist(const pt &p) const
	{
		return side(p) * side(p) / sq(v);
	}
	ln perpThough(const pt &p) const
	{
		return ln(p, p + perp(v));
	}
	pt proj(const pt &p) const
	{
		T k = -side(p) / sq(v);
		return p + k * perp(v);
	}
	pt refl(const pt &p) const
	{
		T k = -2 * side(p) / sq(v);
		return p + k * perp(v);
	}
	bool cmpProj(const pt &p, const pt &q) const
	{
		return dot(v, p) < dot(v, q);
	}
};
inline bool inter(const ln &l1, const ln &l2, pt &out)
{
	T d = cross(l1.v, l2.v);
	if (dcmp(d) == 0) return false;
	out = (l1.c * l2.v - l1.v * l2.c) / d;
	return true;
}

// a, b, c clockwise <=> < 0
// a, b, c counter-clockwise <=> > 0
inline T orient(const pt &a, const pt &b, const pt &c)
{
	return cross(b - a, c - a);
}

inline ln bisector(const ln &l1, const ln &l2, bool interior = true)
{
	double sign = interior ? 1 : -1;
	return { l2.v / abs(l2.v) + l1.v / abs(l1.v) * sign, 
       		l2.c / abs(l2.v) + l1.c / abs(l1.v) * sign};
}

inline bool inDisk(const pt &a, const pt &b, const pt &p)
{
	return dot(a - p, b - p) <= 0;
}

inline bool onSegment(const pt &a, const pt &b, const pt &p)
{
	return dcmp(orient(a, b, p)) == 0 && inDisk(a, b, p);
}

inline bool properInter(const pt &a, const pt &b, const pt &c, const pt &d, pt &out)
{
	T oa = orient(c, d, a), ob = orient(c, d, b), oc = orient(a, b, c), od = orient(a, b, d);
	if (oa * ob < 0 && oc * od < 0)
	{
		out = (a * ob - b * oa) / (ob - oa);
		return true;
	}
	return false;
}

inline T segPoint(const pt &a, const pt &b, const pt &p)
{
	if (a != b)
	{
		ln l(a, b);
		if (l.cmpProj(a, p) && l.cmpProj(p, b))
			return l.dist(p);
	}
	return std::min(abs(p - a), abs(p - b));
}

inline T segSeg(const pt &a, const pt &b, const pt &c, const pt &d)
{
	pt dummy;
	if (properInter(a, b, c, d, dummy)) return 0;
	return std::min({ segPoint(a, b, c), segPoint(a, b, d), segPoint(c, d, a), segPoint(c, d, b) });
}

inline pt incenter(const pt &p1, const pt &p2, const pt &p3)
{
	ln l1(p1, p2), l2(p1, p3), l3(p3, p2);
	ln a = bisector(l1, l2), b = bisector(l1, l3);
	pt bar;
	assert(inter(a, b, bar));
	return bar;
}

inline pt circumcenter(const pt &p1, const pt &p2, const pt &p3)
{
	const ln &l1 = ln(p1, p2).perpThough(midpoint(p1, p2));
	const ln &l2 = ln(p1, p3).perpThough(midpoint(p1, p3));
	pt bar; assert(inter(l1, l2, bar));
	return bar;
}

inline T areaPolygon(std::vector<pt> p)
{
	T area = 0.0;
	for (int i = 0, n = p.size(); i < n; ++i)
	{
		area += cross(p[i], p[(i + 1) % n]);
	}
	return abs(area) / 2.0;
}

inline bool above(const pt &a, const pt &b)
{
	return a.y >= b.y;
}

inline bool crossesRay(const pt &a, const pt &p, const pt &q)
{
	return (above(a, q) - above(a, p)) * orient(a, p, q) > 0;
}

inline bool inPolygon(std::vector<pt> p, const pt &a, bool strict = true)
{
	int c = 0;
	for (int i = 0, n = p.size(); i < n; ++i)
	{
		if (onSegment(p[i], p[(i + 1) % n], a))
			return !strict;
		c ^= crossesRay(a, p[i], p[(i + 1) % n]);
	}
	return c & 1;
}

inline std::vector<pt> convexHull(std::vector<pt> p)
{
	if (p.size() <= 2) return p;
	std::sort(p.begin(), p.end(), [&](const pt &x, const pt &y) { return x.x == y.x ? x.y < y.y : x.x < y.x; });
	std::vector<int> st, vis(p.size());
	st.push_back(0);	
	for (int i = 1; i < p.size(); ++i)
	{
		
		while (st.size() > 1 && orient(p[st[st.size() - 2]], p[st[st.size() - 1]], p[i]) < 0) vis[st.back()] = false, st.pop_back();
		st.push_back(i); vis[i] = true;
	}
	int cur = st.size();
	for (int i = p.size() - 2; i >= 0; --i)
	{
		if (!vis[i])
		{
			while (st.size() > cur && orient(p[st[st.size() - 2]], p[st[st.size() - 1]], p[i]) < 0) vis[st.back()] = false, st.pop_back();
			st.push_back(i); vis[i] = true;
		}
	}
	std::vector<pt> res;
	for (int i = 0; i < st.size() - 1; ++i) res.push_back(p[st[i]]);
	return res;
}

inline T convexDiameter(std::vector<pt> p)
{
	if (p.size() <= 1) return 0;
	int i0 = 0, j0 = 0, n = p.size();
	auto cmp = [&](const pt &a, const pt &b) 
	{
		return a.x == b.x ? a.y < b.y : a.x < b.x;
	};
	for (int i = 1; i < n; ++i)
	{
		if (cmp(p[i0], p[i])) i0 = i;
		if (cmp(p[i], p[j0])) j0 = i;
	}
	int i = i0, j = j0; T d = 0.0;
	do
	{
		d = std::max(d, abs(p[i] - p[j]));
		if (cross(p[(i + 1) % n] - p[i], p[(j + 1) % n] - p[j]) < 0) i = (i + 1) % n;
		else j = (j + 1) % n;
	} while (i != i0 || j != j0);
	return d;
}

struct cr
{
	T r; pt o;
	cr() : r(), o() {}
	cr(pt o, T r) : r(r), o(o) {}
	bool inside(const pt &p) {
		return dcmp(sq(p - o) - r * r) <= 0;
	}
};


inline int circleLine(const cr &C, const ln &l, std::pair<pt, pt> &out)
{
	T h2 = C.r * C.r - l.sqDist(C.o);
	if (dcmp(h2) >= 0)
	{
		pt p = l.proj(C.o), h = l.v / abs(l.v) * sqrt(h2);
		out = std::make_pair(p - h, p + h);
	}
	return 1 + dcmp(h2);
}

inline int circleCircle(const cr &C1, const cr &C2, std::pair<pt, pt> &out)
{
	pt d = C2.o - C1.o; T d2 = sq(d);
	if (dcmp(d2) == 0)
	{
		assert(dcmp(C1.r - C2.r) != 0);
		return 0;
	}
	T pd = (d2 + C1.r * C1.r - C2.r * C2.r) / 2, h2 = C1.r * C1.r - pd * pd / d2;
	if (h2 >= 0)
	{
		pt p = C1.o + d * pd / d2, h = perp(d) * sqrt(h2 / d2);
		out = std::make_pair(p - h , p + h);
	}
	return 1 + dcmp(h2);
}

inline int tangents(cr C1, cr C2, bool inner, std::vector<std::pair<pt, pt>> &out)
{
	if (inner) C2.r = -C2.r;
	pt d = C2.o - C1.o;
	T dr = C1.r - C2.r, d2 = sq(d), h2 = d2 - dr * dr;
	if (dcmp(d2) == 0 || dcmp(h2) == -1)
	{
		assert(dcmp(h2) != 0);
		return 0;
	}
	for (double k : {-1, 1})
	{
		pt v = (d * dr + perp(d) * sqrtl(h2) * k) / d2;
		out.emplace_back(C1.o + v * C1.r, C2.o + v * C2.r);
	}
	return 1 + (dcmp(h2) > 0);
}

inline cr build(pt a) {
	return cr(a, 0);
}
inline cr build(pt a, pt b) {
	return cr((a + b) / 2, abs(a - b) / 2);
}
inline cr build(pt a, pt b, pt c) {
//	cerr << a << " " << b << " " << c << '\n';
	T w = cross(b - a, c - a);
	T z = 2 * w * w;
	T i = sq(b - c) * dot(a - b, a - c);
	T j = sq(a - c) * dot(b - a, b - c);
	T k = sq(a - b) * dot(c - a, c - b);
	T xx = i * a.x + j * b.x + k * c.x;
	T yy = i * a.y + j * b.y + k * c.y;
	pt O(xx / z, yy / z);
	T da = abs(O - a), db = abs(O - b), dc = abs(O - c);
//	cerr << da << ' ' << db << ' ' << dc << '\n';
//	cerr << "diff: " << abs(da - db) << ' ' << abs(da - dc) << '\n';
//	assert(dcmp(da - db) == 0 && dcmp(da - dc) == 0);
	return cr(O, da);
}

const int N = 7505;
pt p[N], q[3];
T dp[N][N];
vector<pair<int, T>> c[N];

const int mod = (1ll << 31) - 1;
int n, k, s;
inline int go() {
	int r = s;
    s = (s * 233811181ll + 1) % mod;
	return r;
}

int main() {
	std::ios::sync_with_stdio(false);
	cin.tie(nullptr); cout.tie(nullptr);
	cout << std::fixed << std::setprecision(15);
	cin >> n >> k >> s;
	for (int i = 0; i < n; ++i) {
		p[i].x = go();
		p[i].y = go();
	}
	function<cr(int ,int, int)> solve = [&](int t, int n, int m) {
		cr cur;
		if (m == 1) {
			cur = build(q[0]);
		}
		else if (m == 2) {
			cur = build(q[0], q[1]);
		}
		else if (m == 3) {
			return cur = build(q[0], q[1], q[2]);
		}
		for (int i = t; i < n; ++i) {
			if (!cur.inside(p[i])) {
				q[m] = p[i];
				cur = solve(t, i, m + 1);
				if (!m)
					c[t].emplace_back(i, cur.r);
			}
		}
		if (!m) c[t].emplace_back(n, 1e18);
		return cur;
	};
	for (int i = 0; i < n; ++i) {
		solve(i, n, 0);
	}
	for (int i = 0; i <= k; ++i)
		for (int j = 0; j < n; ++j)
			dp[i][j] = 1e100;
	for (int i = 1; i <= k; ++i) {
		for (int j = n - 1; j >= 0; --j) {
			dp[i][j] = dp[i-  1][j];
			for (int t = 0; t + 1 < c[j].size(); ++t) {
				int k = c[j][t + 1].first;
				T cost = c[j][t].second;
				dp[i][j] = min(dp[i][j], dp[i - 1][k] + cost);
			}
		}
	}	
	cout << dp[k][0] << '\n';
	return 0;
}