#include <bits/stdc++.h>
#ifdef SHARAELONG
#include "../../cpp-header/debug.hpp"
#endif
using namespace std;
typedef long double ld;
typedef long long ll;

const ll pr = 233811181;
const ll mod = (1ll<<31)-1;

struct Point {
    ld x, y;
    Point operator-(const Point& r)const {return Point{x-r.x, y-r.y};}
    ld operator*(const Point& r) const {return x*r.x+y*r.y;}
    ld operator^(const Point& r) const {return x*r.y-y*r.x;}
};

struct Circle{Point p; ld r;};

ld dst(Point a, Point b){
    return sqrt((a-b)*(a-b));
}

const int MAX_N = 2000 + 1;

ld dp[MAX_N][MAX_N];
ld cost[MAX_N][MAX_N];
Point pp[MAX_N][MAX_N];
int ss[MAX_N][MAX_N];

Point getCenter(Point a, Point b){ return {(a.x+b.x)/2, (a.y+b.y)/2};}
Point getCenter(Point a, Point b, Point c){
    Point aa = b - a, bb = c - a;
    auto c1 = aa*aa * 0.5, c2 = bb*bb *0.5;
    auto d = aa ^ bb;
    auto x = a.x + (c1 * bb.y - c2 * aa.y) / d;
    auto y = a.y + (c2 * aa.x - c1 * bb.x) / d;
    return {x, y};
}
Circle solve(vector<Point> v, int s){
    Point p = {0, 0};
    ld r = 0;
    int n = v.size();
    for(int i=0; i<n; i++) {
        if (dst(p, v[i]) > r) {
            p = v[i];
            r = 0;
            for(int j=0; j<i; j++) {
                if(dst(p, v[j]) > r) {
                    p = getCenter(v[i], v[j]);
                    r = dst(p, v[i]);
                    for(int k=0; k<j; k++) {
                        if(dst(p, v[k]) > r){
                            p = getCenter(v[i], v[j], v[k]);
                            r = dst(v[k], p);
                        }
                    }
                }
            }
        }
        pp[s][s+i] = p;
        cost[s][s+i] = r;
    }
    return {p, r};
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, K, X;
    cin >> N >> K >> X;
    vector <Point> input(N);
    ll seed = X;
    input[0].x = X;
    input[0].y = seed = (seed*pr+1) % mod;
    for(int i=1;i<N;i++){
        input[i].x = seed = (seed*pr+1) % mod;
        input[i].y = seed = (seed*pr+1) % mod;
    }

    for (int s=0; s<N; ++s) {
        vector<Point> v(input.begin()+s, input.end());
        solve(v, s);
    }

    cout << fixed << setprecision(12);

    vector<vector<int>> improved(N+1);
    for (int n=0; n<N; ++n) {
        dp[1][n] = cost[0][n];
        improved[1].push_back(n);
        for (int k=min(K, n+1); k>=2; --k) {
            if (k != n+1 && dst(pp[ss[k][n-1]][n-1], input[n]) < cost[ss[k][n-1]][n-1]) {
                dp[k][n] = dp[k][n-1];
                ss[k][n] = ss[k][n-1];
                improved[k].back() = n;
            } else {
                dp[k][n] = 1e18;
                for (int i=(int)improved[k-1].size()-1; i>=0; --i) {
                    int t = improved[k-1][i];
                    if (t < k-2) break;
                    if (dp[k][n] > dp[k-1][t] + cost[t+1][n]) {
                        dp[k][n] = dp[k-1][t] + cost[t+1][n];
                        ss[k][n] = t+1;
                    }
                }
                improved[k].push_back(n);
            }
        }
    }
    cout << dp[K][N-1];
}