#include <fstream>
#include <string.h>
#include <memory.h>

using namespace std;

const int MAXN = 18;
const int T = 3;
const int oo = 0x3f3f3f3f;

int dp[(1 << MAXN)][MAXN];
int N, G, c[MAXN];

inline int binarySearch(const int &conf) {
    int li = 1, ls = N;
    int ret = 1;
    while(li <= ls) {
        int mid = (li + ls) / 2;
        if(dp[conf][mid] != oo) {
            ret = mid;
            ls = mid - 1;
        }
        else
            li = mid + 1;
    }
    return ret;
}

int main() {
    ifstream fin("zebughil.in");
    ofstream fout("zebughil.out");
    for(int test = 1 ; test <= T ; ++ test) {
        fin >> N >> G;
        for(int i = 0 ; i < N ; ++ i)
            fin >> c[i];
        memset(dp, oo, sizeof(dp));
        for(int i = 0 ; i < N ; ++ i)
            dp[(1 << i)][1] = c[i];
        int maxConf = (1 << N);
        /// O(2^N * N ^ 2)
        for(int conf = 0 ; conf < maxConf ; ++ conf)
            for(int i = 1; i <= N ; ++ i) {
                if(dp[conf][i] == oo)
                    continue;
                for(int j = 0 ; j < N ; ++ j) {
                    if((conf & (1 << j)) == 0) {
                        int newConf = (conf | (1 << j));
                        if(dp[conf][i] + c[j] > G) {
                            dp[newConf][i + 1] = min(dp[newConf][i + 1], c[j]);
                        }
                        else dp[newConf][i] = min(dp[newConf][i], dp[conf][i] + c[j]); /// BUG
                        /// Be careful with the names of variables
                    }
                }
            }
       for(int i = 1 ; i <= N ; ++ i)
            if(dp[maxConf - 1][i] != oo) {
                fout << i << '\n';
                break;
        /// O(N)
            }
/*      /// too greedy
        /// O(log(N))
        fout << binarySearch(maxConf - 1) << '\n';
*/
    }
    /// big-O complexity : O(2^N * N ^ 2)
    return 0;
}