/*
剪枝的策略
1. 优化搜索顺序
    大部分情况下，我们应该优先搜索分支较少的节点
2. 排出等效冗余
3. 可行性剪枝
4. 最优性剪枝
5. 记忆性搜索（DP）
*/

import java.io.*;
class Main {
    static int N = 20;
    static int n, m;
    static int res = N;
    static int[] w = new int[N];
    static int[] sum = new int[N];  // 存放每个车当前的重量
    static void sort(int l, int r) {
        if (l >= r) return;
        int i = l - 1, j = r + 1, p = w[l + r >> 1];
        while (i < j) {
            do i++; while (w[i] > p);
            do j--; while (w[j] < p);

            if (i < j) {
                int t = w[i];
                w[i] = w[j];
                w[j] = t;
            }
        }
        sort(l, j);
        sort(j + 1, r);
    }
    // 准备放第u只猫，车的数量是k
    static void dfs(int u, int k) {
        // 最优性剪枝
        if (k >= res) return;
        if (u == n) {
            res = k;
            return;
        }

        for (int i = 0; i < k; i++) {
            if (sum[i] + w[u] <= m) {  // 可行性剪枝
                sum[i] += w[u];
                dfs(u + 1, k);
                sum[i] -= w[u]; // 恢复现场
            }
        }
        // 新增一辆车
        sum[k] = w[u];
        dfs(u + 1, k + 1);
        sum[k] = 0;

    }
    public static void main(String[] args) throws IOException {
        BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
        String[] s = cin.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);
        for (int i = 0; i < n; i++) {
            s = cin.readLine().split(" ");
            w[i] = Integer.parseInt(s[0]);
        }
        sort(0, n - 1);  // 从打到小排序，先选大的能够优化搜索顺序

        dfs(0, 0);

        System.out.println(res);
    }
}