#include <bits/stdc++.h>
using namespace std;

using ld = long double;

struct Vector {
    ld x;
    ld y;

    Vector(ld x = 0, ld y = 0): x(x), y(y) {}
    ld sqlen() const { return x * x + y * y; }
};

Vector operator+(const Vector& a, const Vector& b) {
    return {a.x + b.x, a.y + b.y};
}

Vector operator-(const Vector& a, const Vector& b) {
    return {a.x - b.x, a.y - b.y};
}

Vector operator/(const Vector& a, ld k) {
    return {a.x / k, a.y / k};
}

const ld EPS = 1e-6;

struct Circle {
    Vector o;
    ld r2;

    bool in(const Vector& v) {
        return (v - o).sqlen() <= r2 + EPS;
    }
};

Circle build() {
    return {Vector(), 0};
}

Circle build(const Vector& v) {
    return {v, 0};
}

Circle build(const Vector& a, const Vector& b) {
    Vector o = (a + b) / 2;
    return {o, (o - a).sqlen()};
}

Circle build(const Vector& a, const Vector& b, const Vector& c) {
    ld a1 = 2 * (b.x - a.x), b1 = 2 * (b.y - a.y), c1 = b.sqlen() - a.sqlen();
    ld a2 = 2 * (c.x - a.x), b2 = 2 * (c.y - a.y), c2 = c.sqlen() - a.sqlen();
    ld x = (c1 * b2 - b1 * c2) / (a1 * b2 - b1 * a2);
    ld y = (a1 * c2 - c1 * a2) / (a1 * b2 - b1 * a2);
    Vector o(x, y);
    return {o, (o - a).sqlen()};
}

const int MAXN = 2e3 + 100;
Vector pts[MAXN];

Circle minDisk(int l, int r, const Vector& a, const Vector& b, const Vector& c) {
    return build(a, b, c);
}

template<typename... Args>
Circle minDisk(int l, int r, Args... args) {
    Circle cur = build(args...);
    /// cerr << l << " " << r << endl;
    for (int i = l; i < r; ++i) {
        /// cerr << i << endl;
        if (!cur.in(pts[i])) {
            cur = minDisk(l, i, pts[i], args...);
        }
        /// cerr << i << " done" << endl;
    }
    /// cerr << l << " " << r << " done" << endl;
    return cur;
}

ld go[MAXN][MAXN];

const int64_t P = 233811181;
const int64_t MOD = (1ll << 31) - 1;

const ld INF = 1e18;

ld dp[MAXN][MAXN];
vector<int> nxt[MAXN];

void dc(int k, int l, int r, int pl, int pr) {
    if (l >= r) return;
    int m = (l + r) / 2;
    int opt = -1;
    dp[k][m] = INF;
    for (int i = pl; i <= pr && i < m; ++i) {
        if (dp[k][m] > dp[k - 1][i] + go[i][m]) {
            dp[k][m] = dp[k - 1][i] + go[i][m];
            opt = i;
        }
    }
    dc(k, l, m, pl, opt);
    dc(k, m + 1, r, opt, pr);
}

void solve_() {
    int n, k, x0;
    cin >> n >> k >> x0;
    vector<int64_t> all(2 * n);
    all[0] = x0;
    for (int i = 1; i < 2 * n; ++i) {
        all[i] = (all[i - 1] * P + 1) % MOD;
    }
    for (int i = 0; i < n; ++i) {
        pts[i] = Vector(all[2 * i], all[2 * i + 1]);
    }
    /**for (int i = 0; i <= 5; ++i) {
        cerr << pts[i].x << " " << pts[i].y << endl;
    }
    cerr << "input done" << endl;*/
    for (int l = 0; l < n; ++l) {
        /// cerr << l << endl;
        Circle cur = build();
        for (int r = l; r < n; ++r) {
            /// cerr << "r: " << r << endl;
            if (!cur.in(pts[r])) {
                nxt[l].push_back(r);
                cur = minDisk(l, r, pts[r]);
            }
            /// cerr << cur.o.x << " " << cur.o.y << " " << cur.r2 << endl;
            go[l][r + 1] = sqrtl(cur.r2);
        }
        nxt[l].push_back(n);
    }

    /// cerr << "go done" << endl;
    for (int j = 0; j <= k; ++j) {
        for (int i = 0; i <= n; ++i) {
            dp[j][i] = INF;
        }
    }
    dp[0][0] = 0;
    for (int j = 0; j < k; ++j) {
        for (int i = 0; i < n; ++i) {
            for (int r : nxt[i]) {
                if (r == i) continue;
                dp[j + 1][r] = min(dp[j + 1][r], dp[j][i] + go[i][r]);
            }
        }
    }
    cout << dp[k][n] << "\n";
}

/// #define MULTITEST

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

    cout << fixed << setprecision(20);
    cerr << fixed << setprecision(20);

    int tst = 1;
#ifdef MULTITEST
    cin >> tst;
#endif // MULTITEST
    while (tst--) {
        solve_();
    }
    return 0;
}