#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll M = (1ll << 31) - 1;
const double eps = 1e-8;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

struct Point {
    double x, y;
    Point() {}
    Point(ll x, ll y) : x(x), y(y) {}
};

double dist(Point a, Point b) {
    return hypot(a.x - b.x, a.y - b.y);
}

Point center(Point a, Point b, Point c) {
    Point cen;
    double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1*a1 + b1*b1)/2;
    double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2*a2 + b2*b2)/2;
    double d = a1*b2 - a2*b1;
    cen.x = a.x + (c1*b2 - c2*b1)/d;
    cen.y = a.y + (a1*c2 - a2*c1)/d;
    return cen;
}

void minc(const vector<Point> &p, Point &c, double &r) {
    int n = p.size();
    c = p[0], r = 0;
    for (int i = 1; i < n; i++) {
        if (sgn(dist(p[i], c) - r) > 0) {
            c = p[i], r = 0;
            for (int j = 0; j < i; j++) {
                if (sgn(dist(p[j], c) - r) > 0) {
                    c.x = (p[i].x + p[j].x)/2;
                    c.y = (p[i].y + p[j].y)/2;
                    r = dist(p[j], c);
                    for (int k = 0; k < j; k++) {
                        if (sgn(dist(p[k], c) - r) > 0) {
                            c = center(p[i], p[j], p[k]);
                            r = dist(p[i], c);
                        }
                    }
                }
            }
        }
    }
}

ll f(ll x) {
    return (x * 233811181 + 1) % M;
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    
    int n, k;
    cin >> n >> k;
    int len = n-k+1;

    vector<ll> x(n), y(n);
    cin >> x[0];
    y[0] = f(x[0]);

    for (int i = 1; i < n; i++) {
        x[i] = f(y[i-1]);
        y[i] = f(x[i]);
    }

    for (int i = 0; i < n; i++) {
        cout << x[i] << ' ' << y[i] << endl;
    }

    double ans = numeric_limits<double>::max();

    for (int i = 0; i+len <= n; i++) {
        vector<Point> p;
        for (int j = 0; j < len; j++) {
            p.push_back({x[i+j], y[i+j]});
        }
        Point c; double r;
        minc(p, c, r);
        ans = min(ans, r);
    }

    if (len > 2) {
        len--;
        for (int i = 0; i+len <= n; i++) {
            vector<Point> p;
            for (int j = 0; j < len; j++) {
                p.push_back({x[i+j], y[i+j]});
            }
            Point c; double r;
            minc(p, c, r);
            for (int j = 0; j+1 < len; j++) {
                if (j+1 >= i && j < i+len) continue;
                vector<Point> np;
                np.push_back({x[j], y[j]});
                np.push_back({x[j+1], y[j+1]});
                Point nc; double nr;
                minc(np, nc, nr);
                ans = min(ans, r + nr);
            }
        }
    }

    cout << fixed << setprecision(12) << ans << endl;

    return 0;
}