#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;

int solve(int x, vector<int> &messages) {
    sort(messages.begin(), messages.end());

    int maxMessage = messages[messages.size() - 1];
    while (messages.size() > 0 && messages[messages.size()-1] > x) {
        messages.pop_back(); // Ignore message sizes larged than x
    }

    int n = messages.size();
    if (n == 0) {
        return maxMessage;
    }
    if (n <= 2) {
        return max(maxMessage, messages[n - 1]);
    }
    if (n <= 4) {
        return max(maxMessage, x + 1);
    }
    
    int sum = 0;
    for(int i = 4; i < n; i++) {
        messages[i] = x + 1 - messages[i];
        sum += messages[i];
    }

    // Split all messages except the 4 shortest in two
    // partitions of as equal size as possible using knapsack algorithm

    // Size of knapsack; this is with some extra margin
    // since we're only considering n-4 items, each with max size x.
    int maxLoop = x * ((n + 1) / 2);
        
    bool dp[2][maxLoop];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = true;

    for(int k = 4; k < n; k++) {
        int cur = k & 1, next = 1 - cur;
        for(int i = 0; i < maxLoop; i++) {
            if (dp[cur][i]) {
                dp[next][i] = true;
                if (i + messages[k] < maxLoop) {
                    dp[next][i + messages[k]] = true;
                }
            }
        }
    }

    int partition = n & 1, best = 99999999;
    for(int i = 0; i < maxLoop; i++) {
        if (dp[partition][i]) {
            int j = sum - i;
            best = min(best, x + 1 + max(i, j));
        }
    }

    return max(maxMessage, best);
}


int main() {
    int n, x;
    cin >> n >> x;
    vector<int> messages(n);
    for(int i = 0; i < n; i++) {
        cin >> messages[i];
    }
    cout << solve(x, messages) << endl;
    return 0;
}