#include "bits/extc++.h"

using namespace std;

template <typename T>
void dbgh(const T& t) {
    cerr << t << endl;
}

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t << " | ";
    dbgh(u...);
}

#ifdef DEBUG
#define dbg(...)                                           \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]" \
         << ": ";                                          \
    dbgh(__VA_ARGS__)
#else
#define cerr   \
    if (false) \
    cerr
#define dbg(...)
#endif

using ld = long double;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

template <class T>
int sgn(T x) {
    return (x > 0) - (x < 0);
}
template <class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x = 0, T y = 0) : x(x), y(y) {}
    bool operator<(P p) const {
        return tie(x, y) < tie(p.x, p.y);
    }
    bool operator==(P p) const {
        return tie(x, y) == tie(p.x, p.y);
    }
    P operator+(P p) const {
        return P(x + p.x, y + p.y);
    }
    P operator-(P p) const {
        return P(x - p.x, y - p.y);
    }
    P operator*(T d) const {
        return P(x * d, y * d);
    }
    P operator/(T d) const {
        return P(x / d, y / d);
    }
    T dot(P p) const {
        return x * p.x + y * p.y;
    }
    T cross(P p) const {
        return x * p.y - y * p.x;
    }
    T cross(P a, P b) const {
        return (a - *this).cross(b - *this);
    }
    T dist2() const {
        return x * x + y * y;
    }
    double dist() const {
        return sqrt((double)dist2());
    }
    // angle to x-axis in interval [-pi, pi]
    double angle() const {
        return atan2(y, x);
    }
    P unit() const {
        return *this / dist();
    }  // makes dist()=1
    P perp() const {
        return P(-y, x);
    }  // rotates +90 degrees
    P normal() const {
        return perp().unit();
    }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x * cos(a) - y * sin(a), x * sin(a) + y * cos(a));
    }
    friend ostream& operator<<(ostream& os, P p) {
        return os << "(" << p.x << "," << p.y << ")";
    }
};

using P = Point<ld>;

struct Circle {
    P center;
    ld radius {};

    bool contains(P p) const {
        return (p - center).dist2() <= radius * radius;
    }
};

ld ccRadius(const P& A, const P& B, const P& C) {
    return (B - A).dist() * (C - B).dist() * (A - C).dist() /
           abs((B - A).cross(C - A)) / 2;
}
P ccCenter(const P& A, const P& B, const P& C) {
    P b = C - A, c = B - A;
    return A + (b * c.dist2() - c * b.dist2()).perp() / b.cross(c) / 2;
}

Circle solve(vector<P>& p, vector<P>& r) {
    if (sz(r) == 3) {
        P a = r[0], b = r[1], c = r[2];
        return {ccCenter(a, b, c), ccRadius(a, b, c)};
    } else if (!sz(p)) {
        if (sz(r) == 0) {
            return {P(-1, -1), 0};
        } else if (sz(r) == 1) {
            return {r[0], 0};
        } else if (sz(r) == 2) {
            return {(r[0] + r[1]) / 2, (r[0] - r[1]).dist() / 2};
        } else {
            dbg(sz(r));
            assert(false);
        }
    }
    P cp = p.back();
    p.pop_back();
    auto c = solve(p, r);
    if (c.contains(cp)) {
        p.push_back(cp);
        return c;
    }
    r.push_back(cp);
    c = solve(p, r);
    p.push_back(cp);
    r.pop_back();
    return c;
}

void solve() {
    int n, kv;
    long x0;
    cin >> n >> kv >> x0;
    auto rng_next = [&](long x) -> long {
        return ((x * 233811181) + 1) % ((long(1) << 31) - 1);
    };
    int arr[n][2];
    for (int i = 0; i < n; i++) {
        auto& [x, y] = arr[i];
        if (i) {
            x = int(rng_next(arr[i - 1][1]));
        } else {
            x = int(x0);
        }
        y = int(rng_next(x));
    }
    P parr[n];
    for (int i = 0; i < n; i++) {
        parr[i] = P(arr[i][0], arr[i][1]);
    }
    ld cost[n][n];
    for (int i = 0; i < n; i++) {
        vector<P> p, r;
        Circle cc = solve(p, r);
        for (int j = i; j < n; j++) {
            if (!cc.contains(parr[j])) {
                r.push_back(parr[j]);
                cc = solve(p, r);
                r.pop_back();
            }
            p.push_back(parr[j]);
            cost[i][j] = cc.radius;
        }
    }
    ld dp[n + 1][kv + 1] {};
    int opt[n + 1][kv + 1];
    for (int i = n - 1; i >= 0; i--) {
        fill(dp[i], dp[i] + kv + 1, 1e100);
        for (int j = i; j < n; j++) {
            if (j + 1 < n && cost[i][j] == cost[i][j + 1]) {
                continue;
            }
            for (int k = 0; k < kv; k++) {
                dp[i][k] = min(dp[i][k], dp[j + 1][k + 1] + cost[i][j]);
            }
        }
    }
    cout << dp[0][0] << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(6);
    solve();
}