#pragma GCC optimize("Ofast")

#include "bits/stdc++.h"

#ifdef LOCAL
    #include "debug.h"
#else
    #define dbg(...)
    #define dprint(...)
    #define debug if constexpr (false)
    #define draw_tree(...)
    #define draw_array(...)
#endif // LOCAL

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define rep1n(i, n) for (int i = 1; i <= (n); ++i)
#define repr(i, n) for (int i = (n) - 1; i >= 0; --i)
#define pb push_back
#define eb emplace_back
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define each(x, a) for (auto &x : a)
#define ar array
#define vec vector
#define range(i, n) rep(i, n)

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vl = vector<ll>;
using vpi = vector<pair<int, int>>;
using vvi = vector<vi>;

int Bit(int mask, int b) { return (mask >> b) & 1; }

template<class T>
bool ckmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
bool ckmax(T &a, const T &b) {
    if (b > a) {
        a = b;
        return true;
    }
    return false;
}


const ll INF = 2e18;
const int INFi = 1e9;
const int N = 2e5 + 50;
const int LG = 20;

template<typename T>
int normalize(T value, int mod) {
    if (value < -mod || value >= 2 * mod) value %= mod;
    if (value < 0) value += mod;
    if (value >= mod) value -= mod;
    return value;
}

template<int mod>
struct static_modular_int {
    using mint = static_modular_int<mod>;

    int value;

    static_modular_int() : value(0) {}

    static_modular_int(const mint &x) : value(x.value) {}

    template<typename T, typename U = std::enable_if_t<std::is_integral<T>::value>>
    static_modular_int(T value) : value(normalize(value, mod)) {}

    template<typename T>
    mint power(T degree) const {
        degree = normalize(degree, mod - 1);
        mint prod = 1, a = *this;
        for (; degree > 0; degree >>= 1, a *= a)
            if (degree & 1)
                prod *= a;

        return prod;
    }

    mint inv() const {
        return power(-1);
    }

    mint &operator=(const mint &x) {
        value = x.value;
        return *this;
    }

    mint &operator+=(const mint &x) {
        value += x.value;
        if (value >= mod) value -= mod;
        return *this;
    }

    mint &operator-=(const mint &x) {
        value -= x.value;
        if (value < 0) value += mod;
        return *this;
    }

    mint &operator*=(const mint &x) {
        value = int64_t(value) * x.value % mod;
        return *this;
    }

    mint &operator/=(const mint &x) {
        return *this *= x.inv();
    }

    friend mint operator+(const mint &x, const mint &y) {
        return mint(x) += y;
    }

    friend mint operator-(const mint &x, const mint &y) {
        return mint(x) -= y;
    }

    friend mint operator*(const mint &x, const mint &y) {
        return mint(x) *= y;
    }

    friend mint operator/(const mint &x, const mint &y) {
        return mint(x) /= y;
    }

    mint &operator++() {
        ++value;
        if (value == mod) value = 0;
        return *this;
    }

    mint &operator--() {
        --value;
        if (value == -1) value = mod - 1;
        return *this;
    }

    mint operator++(int) {
        mint prev = *this;
        value++;
        if (value == mod) value = 0;
        return prev;
    }

    mint operator--(int) {
        mint prev = *this;
        value--;
        if (value == -1) value = mod - 1;
        return prev;
    }

    mint operator-() const {
        return mint(0) - *this;
    }

    bool operator==(const mint &x) const {
        return value == x.value;
    }

    bool operator!=(const mint &x) const {
        return value != x.value;
    }

    bool operator<(const mint &x) const {
        return value < x.value;
    }

    template<typename T>
    explicit operator T() {
        return value;
    }

    friend std::istream &operator>>(std::istream &in, mint &x) {
        std::string s;
        in >> s;
        x = 0;
        for (const auto c: s)
            x = x * 10 + (c - '0');

        return in;
    }

    friend std::ostream &operator<<(std::ostream &out, const mint &x) {
        return out << x.value;
    }

    static int primitive_root() {
        if constexpr (mod == 1'000'000'007) return 5;
        if constexpr (mod == 998'244'353) return 3;
        if constexpr (mod == 786433) return 10;

        static int root = -1;
        if (root != -1)
            return root;

        std::vector<int> primes;
        int value = mod - 1;
        for (int i = 2; i * i <= value; i++)
            if (value % i == 0) {
                primes.push_back(i);
                while (value % i == 0)
                    value /= i;
            }

        if (value != 1) primes.push_back(value);
        for (int r = 2;; r++) {
            bool ok = true;
            for (auto p: primes) {
                if ((mint(r).power((mod - 1) / p)).value == 1) {
                    ok = false;
                    break;
                }
            }
            if (ok) return root = r;
        }
    }
};

constexpr int MOD = 1'000'000'009;
// constexpr int MOD = 998'244'353;
using mint = static_modular_int<MOD>;

struct Group {
    ll sum;
    ll val;
    int l, cnt;
};

bool operator<(const Group &a, const Group &b) {
    ll v = a.sum * b.cnt - b.sum * a.cnt;
    if (v != 0) return v < 0;
    return make_pair(a.l, a.val) < make_pair(b.l, b.val);
}

bool operator==(const Group &a, const Group &b) {
    return a.sum == b.sum && a.l == b.l && a.cnt == b.cnt && b.val == a.val;
}

Group Merge(const Group &a, const Group &b) {
    Group c;
    c.l = min(a.l, b.l);
    c.cnt = a.cnt + b.cnt;
    c.val = a.val + b.val + b.sum * a.cnt;
    c.sum = 1ll * a.sum + b.sum;
    return c;
}

void solve() {
    int n;
    ll m;
    cin >> n >> m;
    vl b(n + 1);
    {
        vi a(n);
        rep(i, n) cin >> a[i];
        sort(all(a));
        b[0] = a[0];
        b[n] = m + 1 - a[n - 1];
        for (int i = 1; i < n; ++i) {
            b[i] = a[i] - a[i - 1];
        }
        n++;
    }

    vector<bool> solved(n - 1);
    vector<ll> prec(n - 1);
    
    auto calc = [&](int i) -> ll {
        if (solved[i]) {
            return prec[i];
        }
        assert(0 <= i && i + 1 < n);
        vector<Group> val(n);
        rep(j, n) {
            val[j].l = j;
            val[j].cnt = 1;
            val[j].sum = b[j];
            val[j].val = b[j];
        }
        val[i].sum += b[i + 1];
        val[i].val = val[i].sum;
        priority_queue<Group> pq;
        rep(j, n) {
            if (i == j || j == i + 1) continue;
            pq.push(val[j]);
        }
        vector<bool> alive(n, true);
        while (!pq.empty()) {
            auto g = pq.top();
            pq.pop();
            if (val[g.l] != g || !alive[g.l]) {
                continue;
            }
            if (g.l < i) {
                int to = g.l + g.cnt;
                if (to == val[i].l) {
                    alive[g.l] = false;
                    val[i] = Merge(g, val[i]);
                    continue;
                }
                assert(alive[to]);
                val[g.l] = Merge(g, val[to]);
                alive[to] = false;
                pq.push(val[g.l]);
                assert(val[g.l].l == g.l);
                continue;
            }
            if (g.l > i + 1) {
                int to = g.l - g.cnt;
                if (to == val[i].l + val[i].cnt) {
                    alive[g.l] = false;
                    val[i] = Merge(g, val[i]);
                    continue;
                }
                assert(alive[to]);
                auto nw = Merge(g, val[to]);
                nw.l = g.l;
                val[g.l] = nw;
                alive[to] = false;
                pq.push(val[g.l]);
                assert(val[g.l].l == g.l);
                continue;
            }
            assert(0);
        }
        assert(val[i].cnt == n - 1);
        solved[i] = true;
        return prec[i] = val[i].val;
    };

    // debug {
    //     for (int i = 0; i < n - 1; i++) {
    //         cerr << calc(i) << '\n';
    //     }
    // }

    ll ans = -1e18;
    int who = -1;

    auto update = [&](int i) {
        ll now = calc(i);
        if (now > ans) {
            ans = now;
            who = i;
        }
    };

    for (int i = 0; i < n - 1; i++) {
        if (min(i, n - i) <= 10) {
            update(i);
        }
    }

    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    while (double(clock()) / CLOCKS_PER_SEC < 1.5) {
        update(rng() % (n - 1));
    }

    int pos = who;
    for (int d = 0; d < n && double(clock()) / CLOCKS_PER_SEC < 2.8; d++) {
        if (pos - d >= 0) {
            update(pos - d);
        }
        if (pos + d < n - 1) {
            update(pos + d);
        }
    }

    // auto flex = [&](int left, int right) {
    //     while (right - left >= 3) {
    //         int mid1 = (2 * left + right) / 3;
    //     }
    // };

    cout << ans << '\n';
}


signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
//    cin >> t;
    rep(i, t) {
        solve();
    }
    return 0;
}