#include <bits/stdc++.h>

using i64 = long long;

using F = long double;

constexpr F inf = INFINITY;

constexpr F eps = 1E-12;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(10);
    
    int n, A;
    std::cin >> n >> A;
    
    std::vector<int> a(n + 1);
    for (int i = 0; i <= n; i++) {
        std::cin >> a[i];
    }
    
    std::vector<F> len;
    std::vector<int> type;
    std::vector<int> l, r;
    
    auto check = [&](F x) {
        len.clear();
        type.clear();
        F lst = 0;
        for (int i = 0; i < n; i++) {
            if ((a[i] < x) != (a[i + 1] < x)) {
                F r = i + (x - a[i]) / (a[i + 1] - a[i]);
                len.push_back(r - lst);
                type.push_back(a[i] < x ? -1 : 1);
                lst = r;
            }
        }
        len.push_back(n - lst);
        type.push_back(a[n] >= x ? 1 : -1);
        
        const int m = len.size();
        l.assign(m, -1);
        r.assign(m, -1);
        for (int i = 1; i < m; i++) {
            r[i - 1] = i;
            l[i] = i - 1;
        }
        
        std::priority_queue<std::pair<F, int>, std::vector<std::pair<F, int>>, std::greater<>> pq;
        auto getT = [&](int i) {
            if (l[i] == -1 && r[i] == -1) {
                return inf;
            } else if (l[i] == -1 || r[i] == -1) {
                return len[i] * 2;
            } else {
                return len[i];
            }
        };
        for (int i = 0; i < m; i++) {
            pq.emplace(getT(i), i);
        }
        
        while (!pq.empty()) {
            auto [t, i] = pq.top();
            pq.pop();
            
            if (t > A) {
                continue;
            }
            if (l[i] == -2) {
                continue;
            }
            if (getT(i) > t + eps) {
                continue;
            }
            if (l[i] != -1) {
                int x = l[i];
                len[i] += len[x];
                l[i] = l[x];
                if (l[i] != -1) {
                    r[l[i]] = i;
                }
                l[x] = r[x] = -2;
            }
            if (r[i] != -1) {
                int x = r[i];
                len[i] += len[x];
                r[i] = r[x];
                if (r[i] != -1) {
                    l[r[i]] = i;
                }
                l[x] = r[x] = -2;
            }
            type[i] *= -1;
            pq.emplace(getT(i), i);
        }
        
        for (int i = 0; i < m; i++) {
            if (l[i] != -2 && r[i] != -2 && type[i] == 1) {
                return true;
            }
        }
        return false;
    };
    
    F lo = *std::min_element(a.begin(), a.end()), hi = *std::max_element(a.begin(), a.end());
    
    for (int t = 0; t < 50; t++) {
        F x = (lo + hi) / 2;
        if (check(x)) {
            lo = x;
        } else {
            hi = x;
        }
    }
    
    std::cout << lo << "\n";
    
    return 0;
}