use std::io;
fn read_line() -> String {
    let mut line = String::new();

    io::stdin().read_line(&mut line)
        .expect("Failed to read line");
    return line;
}
fn to_i(s: &str) -> i32 {
    return s.trim().parse()
        .expect("Please type a number!");
}


fn check(index :u32, flags: &mut Vec<bool>, nums: &mut Vec<i32>, val: i32,  s: i32, count:i32) -> i32 {
    let limit = (nums.len()-1) as u32;
    if index>limit {
        
         //println!("nums:{:?} flags:{:?} {} {} {}", nums, flags, count, val ,sum);
        if s == val {
            return count;
        } else if s < val {
            if count ==0 {
                return 0;
            }
            return count-1;
        }
        return 0;
    } 
    
    
    
    let mut calc1 = true;
    let mut calc2 = true;
    let mut c1 = 0;
    let mut c2 = 0;

    let mut max_v = s;
    for i in index+1..(nums.len() as u32) {
        max_v += nums[i as usize];
    }
    if max_v < val {
        calc1 = false;
    }

    let  s2 = s + nums[index as usize];
    if s2 > val {
        //println!("= {} nums:{:?} flags:{:?} {} {} {} {} ", index, nums, flags, count, val ,s, s2);
            
        calc2 = false;
    }

    if !calc1 && !calc2 {

    }

    if calc1 {
        flags[index as usize] = false;
        c1 = check(index+1, flags, nums, val, s, count);
    }

    

    if calc2 {
        flags[index as usize] = true;
        c2 = check(index+1, flags, nums, val, s2, count+1);
    }

    

    
    /*
    if s2==val {
        //println!("= {} nums:{:?} flags:{:?} {} {} {}", index, nums, flags, count, val ,s);
        c2 = count+1;
    //} else if s2 > val {
    //    c2 = count ;
        //println!("> {} nums:{:?} flags:{:?} {} {} {}", index, nums, flags, count, val ,s);
        
    } else {
        c2 = check(index+1, flags, nums, val, s2, count+1);
    }
*/

    if calc1 && calc2 {
        if c1>c2 {
            return c1;
        }else {
            return c2;
        }
    }

    if calc1 && !calc2 {
        return c1;
    }
    if !calc1 && calc2 {
        return c2;
    }
    
    
    if s == val {
            return count;
        } else if s < val {
            if count ==0 {
                return 0;
            }
            return count-1;
        }
        return 0;
}
fn main() {

    let l1 = read_line();
    
    let nx: Vec<&str> = l1.split(' ').collect();

    let _n: i32 = to_i(nx[0]);
    let x: i32 = to_i(nx[1]);

    let l2 = read_line();
    

    let items: Vec<&str> = l2.split(' ').collect();
    //println!("items:{:?}", items);

    let mut nums: Vec<i32> = Vec::new();

    for item in items {
        nums.push(to_i(item));
    }
    nums.sort();
    nums.reverse();

    let mut flags: Vec<bool> = Vec::new();
    for i in 0..nums.len() {
        flags.push(false);
    }
    let count = check(0, &mut flags, &mut nums, x, 0, 0);


    print!("{}", count);


}   