#include <iostream>
#include <vector>
using namespace std;

long long countSubsets(vector<int>& cargoWeights, int shipCapacity) {
    int n = cargoWeights.size();
    
    // Helper function for recursion
    function<long long(int, int)> dfs = [&](int index, int currentSum) -> long long {
        // Base case: if we've considered all items
        if (index == n) {
            return (currentSum <= shipCapacity) ? 1 : 0;
        }
        
        // Option 1: Don't include the current item
        long long countWithout = dfs(index + 1, currentSum);
        
        // Option 2: Include the current item (if it doesn't exceed capacity)
        long long countWith = 0;
        if (currentSum + cargoWeights[index] <= shipCapacity) {
            countWith = dfs(index + 1, currentSum + cargoWeights[index]);
        }
        
        return countWithout + countWith;
    };
    
    return dfs(0, 0);
}

int main() {
    int n, shipCapacity;
    cin >> n >> shipCapacity;
    
    vector<int> cargoWeights(n);
    for (int i = 0; i < n; i++) {
        cin >> cargoWeights[i];
    }
    
    cout << countSubsets(cargoWeights, shipCapacity) << endl;
    return 0;
}

import java.util.*;
import java.io.*;

public class Main {
    public static long countSubsets(int[] cargoWeights, int shipCapacity) {
        int n = cargoWeights.length;
        
        // Helper function for recursion
        return dfs(cargoWeights, shipCapacity, 0, 0, n);
    }
    
    private static long dfs(int[] cargoWeights, int shipCapacity, int index, int currentSum, int n) {
        // Base case: if we've considered all items
        if (index == n) {
            return currentSum <= shipCapacity ? 1 : 0;
        }
        
        // Option 1: Don't include the current item
        long countWithout = dfs(cargoWeights, shipCapacity, index + 1, currentSum, n);
        
        // Option 2: Include the current item (if it doesn't exceed capacity)
        long countWith = 0;
        if (currentSum + cargoWeights[index] <= shipCapacity) {
            countWith = dfs(cargoWeights, shipCapacity, index + 1, currentSum + cargoWeights[index], n);
        }
        
        return countWithout + countWith;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int shipCapacity = Integer.parseInt(st.nextToken());
        
        int[] cargoWeights = new int[n];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            cargoWeights[i] = Integer.parseInt(st.nextToken());
        }
        
        System.out.println(countSubsets(cargoWeights, shipCapacity));
    }
}

def count_subsets(cargo_weights, ship_capacity):
    n = len(cargo_weights)
    
    def dfs(index, current_sum):
        # Base case: if we've considered all items
        if index == n:
            return 1 if current_sum <= ship_capacity else 0
        
        # Option 1: Don't include the current item
        count_without = dfs(index + 1, current_sum)
        
        # Option 2: Include the current item (if it doesn't exceed capacity)
        count_with = 0
        if current_sum + cargo_weights[index] <= ship_capacity:
            count_with = dfs(index + 1, current_sum + cargo_weights[index])
        
        return count_without + count_with
    
    return dfs(0, 0)

if __name__ == "__main__":
    import sys
    input_data = sys.stdin.read().split()
    idx = 0
    n = int(input_data[idx]); idx += 1
    ship_capacity = int(input_data[idx]); idx += 1
    cargo_weights = []
    for i in range(n):
        cargo_weights.append(int(input_data[idx])); idx += 1
    
    print(count_subsets(cargo_weights, ship_capacity))

function countSubsets(cargoWeights, shipCapacity) {
    const n = cargoWeights.length;
    
    // Helper function for recursion
    function dfs(index, currentSum) {
        // Base case: if we've considered all items
        if (index === n) {
            return currentSum <= shipCapacity ? 1 : 0;
        }
        
        // Option 1: Don't include the current item
        const countWithout = dfs(index + 1, currentSum);
        
        // Option 2: Include the current item (if it doesn't exceed capacity)
        let countWith = 0;
        if (currentSum + cargoWeights[index] <= shipCapacity) {
            countWith = dfs(index + 1, currentSum + cargoWeights[index]);
        }
        
        return countWithout + countWith;
    }
    
    return dfs(0, 0);
}

// Driver code
const fs = require('fs');
const input = fs.readFileSync(0, 'utf8').split(/\s+/).map(Number);
let idx = 0;
const n = input[idx++];
const shipCapacity = input[idx++];
const cargoWeights = [];
for (let i = 0; i < n; i++) {
    cargoWeights.push(input[idx++]);
}

console.log(countSubsets(cargoWeights, shipCapacity));