#include <bits/stdc++.h>
using namespace std;
// #define PDD pair<long double, long double>
typedef pair<long double,long double> PDD;
#define MOD ((1ll << 31) - 1)
int X[2010], Y[2010];

long double dis[2010][2010];
long double get_dis(int x1, int y1, int x2, int y2) {
    long double ret = sqrt(1ll * (x1 - x2) * (x1 - x2) + 1ll * (y1 - y2) * (y1 - y2));
    return ret;
}
long double f[2010][2010];

struct Circle{		//存圆
    PDD o;		//圆心o
    long double r;	//半径r
}c;   
namespace CALC{
    const int N = 100010;
    const long double eps = 1e-8,PI = acos(-1);	//会用到的常数
    #define x first		//方便用pair
    #define y second
    
    
    PDD p[N];	//p来存点
    int n;

    PDD operator+(PDD a,PDD b)	//重在运算符+，方便pair运算
    {
        return {a.x+b.x, a.y+b.y};
    }

    PDD operator-(PDD a,PDD b)
    {
        return {a.x-b.x, a.y-b.y};
    }

    double operator*(PDD a,PDD b)	//叉乘
    {
        return a.x*b.y - a.y*b.x;	//x1*y2 - x2*y1
    }

    PDD operator*(PDD a,long double b)	//数乘
    {
        return {a.x*b, a.y*b};
    }

    PDD operator/(PDD a,long double b)
    {
        return {a.x/b, a.y/b};
    }

    int judge(long double a,long double b)	//两个double数比大小，相等返回0，小于返回-1，大于返回1
    {
        if(fabs(a-b) < eps)
            return 0;
        if(a < b)
            return -1;
        return 1;
    }

    PDD rotate(PDD a,long double b)	//向量a旋转b°后的向量，基础知识中有证明
    {
        return {a.x*cos(b)+a.y*sin(b), -a.x*sin(b)+a.y*cos(b)};
    }

    long double lens(PDD a,PDD b)	//求两点距离
    {
        long double dx = a.x - b.x;
        long double dy = a.y - b.y;
        return sqrt(dx*dx + dy*dy);	//根号下x方加y方
    }

    PDD intersection(PDD p,PDD v,PDD q,PDD w)	//求两直线交点，详见基础知识
    {
        PDD u = p - q;
        long double t = w*u / (v*w);
        return p + v*t;
    }

    pair<PDD,PDD> bisector(PDD a,PDD b)	//求两点中垂线
    {
        PDD p = (a+b) / 2;	//先求出a和b连线的中点，就是横纵坐标和的一半
        PDD v = rotate(b-a,PI/2);	//然后求ab向量旋转90°的向量
        return {p,v};		//就有了直线上一点p和一个向量v，根据点向式可以写出一条直线方程
    }

    Circle circle(PDD a,PDD b,PDD c)	//已知三点，求外接圆
    {
        auto n = bisector(a,b),m = bisector(a,c);	//先求出两个边的中垂线
        PDD o = intersection(n.x,n.y,m.x,m.y);	//然后求两中垂线交点就是圆心o
        long double r = lens(o,a);	//求出oa长度就是半径
        return {o,r};		//返回圆心和半径
    }

    Circle solve(int L, int R) {
        n = R - L + 1;
        for(int i = 0, j = L;i < n, j<=R;j++,i++)
            p[i].x = X[j], p[i].y = Y[j];
        
        c = {p[0],0};			//初始化圆为p[0]
        for(int i = 1;i < n;i++)	//第一次循环
        {
            if(judge(c.r,lens(c.o,p[i])) == -1)	//如果p[i]在圆外
            {
                c = {p[i],0};			//初始化圆为p[i]
                for(int j = 0;j < i;j++)	//第二层循环
                {
                    if(judge(c.r,lens(c.o,p[j])) == -1)	//如果p[j]在圆外
                    {
                        c = {(p[i]+p[j])/2,lens(p[i],p[j])/2};	//初始化圆为p[i]和p[j]为直径的圆
                        for(int k = 0;k < j;k++)	//第三层循环
                        {
                            if(judge(c.r,lens(c.o,p[k])) == -1)	//如果p[k]在圆外
                                c = circle(p[i],p[j],p[k]);		//i、j、k三点求一个唯一的圆
                        }
                    }
                }
            }
        }
        return c;
    }
    
}
long double p[2010][2010];
	
vector<pair<int, long double>> from[2010];
signed main() {
	ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
	int n, K;
    cin >> n >> K >> X[1];
    for(int i = 1; i <= n; ++ i) {
        if(i > 1) {
            X[i] = ((Y[i - 1] * 233811181ll) + 1) % MOD;
        }
        Y[i] = ((X[i] * 233811181ll) + 1) % MOD;
    }
    for(int i = 1; i <= n; ++ i) {
        for(int j = i; j <= n; ++ j) {
            dis[i][j] = dis[j][i] = get_dis(X[i], Y[i], X[j], Y[j]);
        }
    }
    // int tim = clock();
    for(int i = 1; i <= n; ++ i) {
        Circle now = CALC::solve(i - 1, i);
        p[i - 1][i] = now.r;
        from[i].push_back({i - 1, 0});
        from[i].push_back({i - 2, p[i - 1][i]});
        // cerr << i << endl;
        for(int j = i - 2; j >= 1; -- j)  {
            if(now.r * now.r >= (X[j] - now.o.first) * (X[j] - now.o.first) + (Y[j] - now.o.second) * (Y[j] - now.o.second)) {
                p[j][i] = p[j + 1][i];
                from[i][from[i].size() - 1].first = j - 1;
            }
            else {
                // cerr << "XD 233" << endl;
                now = CALC::solve(j, i);
                p[j][i] = now.r;
                from[i].push_back({j - 1, p[j][i]});
            }
            // p[i][j] = p[i][j - 1];
            // for(int k = i; k <= j - 1; ++ k) {
            //     p[i][j] = max(p[i][j], dis[k][j]);
            // } 
            // cerr << i << " " << j << " " << p[i][j] << endl;
        }

    }
    // cerr << clock() - tim << endl;
    for(int i = 0; i <= n; ++ i) {
        for(int j = 0; j <= n; ++ j) {
            f[i][j] = 1e18;
        }
    }
    f[0][0] = 0;
    for(int i = 1; i <= n; ++ i) {
        for(int j = 1; j <= K && j <= i; ++ j) {
            // f[i][j] = 1e15;
            for(auto [k, pp] : from[i]) {
                f[i][j] = min(f[i][j], f[k][j - 1] + pp);
            }
            f[i][j] = min(f[i][j], f[j - 1][j - 1] + p[j][i]); 
            // for(int k = 0ll; k <= i - 1; ++ k) {
            //     // if(i == 1 && j == 1) {
            //     //     cerr << p[k + 1][i] << endl;
            //     // }
            //     f[i][j] = min(f[i][j], f[k][j - 1] + p[k + 1][i]);
            // }
            // if(i <= 20) cerr << i << " " << j << " " << f[i][j] << endl;
        }
    }
    cout << fixed << setprecision(20) << f[n][K] << endl;
}