#include<bits/stdc++.h>

using namespace std;

#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define pf push_front
#define LC k<<1
#define RC k<<1|1
#define IO cin.sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define rep(i,a,n) for (int i = a; i < n; i++)
#define repn(i,a,n) for (int i = a; i <= n; i++)
#define per(i,a,n) for (int i = (n) - 1; i >= a; i--)
#define pern(i,a,n) for (int i = n; i >= a; i--)

typedef long long LL;
typedef long double LD;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<int, LL> PIL;
typedef pair<LL, int> PLI;
typedef pair<double, double> PDD;
typedef pair<ull, ull> PUU;
typedef pair<LL, LL> PLL;

const int N = 2100;
const int M = 1100000;
const LL mod = (1LL << 31) - 1;
const LL B = 233811181;
const int inf = (int)1e9;
const LL INF = 1e18;
const double eps = 1e-9;

mt19937_64 Rand((unsigned long long)new char);
#define rand Rand

int n, k, x[N], y[N];
int nxt(LL x) {
	LL res = (x * B + 1) % mod;
	return res;
}
double ans;
set<int> S;
const double pi = acos(-1.0);
inline int dcmp(double x) {
    return (x > eps) - (x < -eps);
}

struct Point {
    double x, y;
    Point (double x = 0 , double y = 0) : x(x) , y(y) {}
    void input() {
        scanf("%lf%lf",&x,&y);
    }
    bool operator < (const Point& R) const {
        if (dcmp(x - R.x) == 0)
            return dcmp(y - R.y) < 0;
        return dcmp(x - R.x) < 0;
    }
    bool operator == (const Point& R) const {
        return dcmp(x - R.x) == 0 && dcmp(y - R.y) == 0;
    }
    Point operator + (const Point& R) const {
        return Point(x + R.x, y + R.y);
    }
    Point operator - (const Point& R) const {
        return Point(x - R.x, y - R.y);
    }
    Point operator * (const double& R) const {
        return Point(x * R, y * R);
    }
    Point operator / (const double& R) const {
        return Point(x / R, y / R);
    }
    double operator ^ (const Point& R) const {
        return x * R.y - y * R.x;
    }
    double operator % (const Point& R) const {
        return x * R.x + y * R.y;
    }
    double len() {
        return sqrt(*this % *this);
    }
    double angle() {
        return atan2(y, x);
    }
}p[N];
Point Normal(Point A) {
    double L = A.len();
    return Point(-A.y / L , A.x / L);
}
struct Circle {
    Point O;
    double r;
    Circle () {}
    Circle (Point _O , double _r) {
        O = _O , r = _r;
    }
    Point point(double arc) {
        return Point(O.x + cos(arc) * r , O.y + sin(arc) * r);
    }
    void input() {
        O.input() , scanf("%lf",&r);
    }
};
Point GetLineIntersection(Point P, Point v, Point Q, Point w) {
    Point u = P - Q;
    double t1 = (w ^ u) / (v ^ w);
    return P + v * t1;
}
Circle CircumscribedCircle(Point A , Point B , Point C) {
    Point D = (B + C) / 2 , d = Normal(B - C);
    Point E = (A + C) / 2 , e = Normal(A - C);
    Point P = GetLineIntersection(D , d , E , e);
    return Circle(P , (C - P).len());
}
double GetDist(Point A, Point B) {
	return (A - B).len();
}
double r[N][N], dp[N][N];
int s[N][N];
const int L = 50;
int main() {
	IO;
	cin >> n >> k >> x[1];
	// n = 2000, k = 1000, x[1] = 8831;
	y[1] = nxt(x[1]);
	repn(i, 2, n) {
		x[i] = nxt(y[i - 1]);
		y[i] = nxt(x[i]);
	}
	repn(i, 1, n) p[i] = Point(x[i], y[i]);
	repn(i, 1, n) {
		Circle c = Circle(p[i], 0);
		repn(j, i + 1, n) {
			if (GetDist(p[j], c.O) > c.r + eps) {
				c = Circle(p[j], 0);
				rep(k, i, j) {
					if (GetDist(p[k], c.O) > c.r + eps) {
						c.O = (p[j] + p[k]) / 2;
						c.r = GetDist(c.O, p[k]);
						rep(l, i, k) {
							if (GetDist(p[l], c.O) > c.r + eps) {
								c = CircumscribedCircle(p[j], p[k], p[l]);
							}
						}
					}
				}
			}
			r[i][j] = c.r;
		}
	}
	repn(i, 0, n) repn(j, 0, k) dp[i][j] = 1e20;
	dp[0][0] = 0;
	repn(i, 1, k) repn(j, i, n) {
		int len = j / i;
		repn(l, i - 1, i - 1 + L) if (l < j && l >= i - 1) dp[j][i] = min(dp[j][i], dp[l][i - 1] + r[l + 1][j]);
		repn(l, j - L, j - 1) if (l < j && l >= i - 1) dp[j][i] = min(dp[j][i], dp[l][i - 1] + r[l + 1][j]);
//		rep(l, 0, j) {
//			if (dp[l][i - 1] + r[l + 1][j] < dp[j][i]) {
//				dp[j][i] = dp[l][i - 1] + r[l + 1][j];
//				s[j][i] = l;
//			}
//		}
	}
	// repn(i, 1, n) repn(j, 1, k) {
	// 	assert((i - s[i][j]) <= j + 20 || s[i][j] <= j + 20);
	// }
	cout << fixed << setprecision(15) << dp[n][k] << "\n";
	return 0;
}