#include <bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

// less_equal here isn't related to order_of_key, but to how elements are stored
// swapping here works like this : ors1.swap(ors2);
// NOTE : default order is ascending with no repetition.
template<typename K, typename V, typename Comp = less<K>>
using order_statistic_map = tree<K, V, Comp, rb_tree_tag, tree_order_statistics_node_update>;

template<typename K, typename Comp = less<K>>
using order_statistic_set = order_statistic_map<K, null_type, Comp>;

#define int long long
#define ld long double
#define el '\n'
#define fi first
#define se second

#define Nine_seconds ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);

const int INF = 1e17;
const int N = 1e3 + 7;
const int C = 1e5 + 7;
int n, c;
map<int, int> cnt;

struct state {
    int pos;
    int rem;
};

bool relax(int &a, int b) {
    if (a < b) return false;
    a = b;

    return true;
}

void run_case(int tc) {
    cin >> n >> c;
    vector<int> w(n);
    for (int i = 0; i < n; i++) {
        cin >> w[i];
        cnt[w[i]] += 1;
    }
sort(w.begin(),w.end());

    int dp[n + 1][c + 1];
    state par[n + 1][c + 1];

    for (int i = 0; i < n + 1; i++)
        for (int j = 0; j < c + 1; j++)
            dp[i][j] = INF, par[i][j] = {-1, -1};

    dp[0][c] = 0;

    for (int i = 0; i < n; i++) {
        for (int rem = c; rem >= 0; rem--) {   // rem
            if(relax(dp[i + 1][rem - w[i]], dp[i][rem] + w[i])) { // take i
                par[i + 1][rem - w[i]] = {i, rem};
            }
            if(relax(dp[i + 1][rem], dp[i][rem])) { // leave i
                par[i + 1][rem] = {i, rem};
            }
        }
    }

    int ans = INF;
    for (int rem = 0; rem <= c; rem++) {
        state cur = {n, rem};
        while(~cur.pos) {
            int wt = par[cur.pos][cur.rem].rem - cur.rem;
            //if (rem == 2) cout << cur.pos << ' ' << cur.rem << ' ' << dp[cur.pos][cur.rem] << ' ' << wt << el;
            cnt[wt] -= 1;
            cur = par[cur.pos][cur.rem];
        }

        bool bad = false;
        for (auto [f, s]: cnt) {
            if (s > 0 && f <= rem) {
                bad = true;
                break;
            }
        }

        if (!bad)
            relax(ans, dp[n][rem]);

        for (int i = 0; i < n; i++)
            cnt[w[i]] = 0;

        for (int i = 0; i < n; i++)
            cnt[w[i]] += 1;
    }

    cout << ans << el;
}


int32_t main() {
//    Nine_seconds        /*Turn Off for Interactive Problems*/

    int _t = 1;
    //cin >> _t;
    for (int i = 1; i <= _t; i++) {
        run_case(i);
    }

}