import sys

n , k = map(int,sys.stdin.readline().split())
coins = list()
dp = [0 for _ in range(k+1)]
for _ in range(n):
    coins.append(int(sys.stdin.readline()))
# 가치가 작은 coin 부터 적용
coins.sort()
dp[0] = 1

for c in coins:
    for i in range(c, k+1) :
        dp[i] = dp[i] + dp[i-c]
print(dp[k])

import sys

n , k  = map(int, sys.stdin.readline().split())
coins = list()
for _ in range(n):
    coins.append(int(sys.stdin.readline()))

coins.sort() 

# 2. dp 테이블 초기화
INF= int(1e9)
dp = [INF for _ in range(k+1)]
dp[0] = 0 
for c in coins :
    for j in range(c, k+1) :
        dp[j] = min(dp[j] , dp[j-c]+1)

#3. 출력 - 업데이트x 면 -1 출력
if dp[k] == INF : 
    print(-1)
else : 
    print(dp[k])

from collections import deque
def get_outlier(x1,y1,x2,y2):

    pos_outliers = list()
    # 가로 
    for x in range(x1,x2+1,1):
        pos_outliers.append([x,y1])
        pos_outliers.append([x,y2])
    # 세로
    for y in range(y1, y2+1, 1):
        if  [x1,y] in pos_outliers or [x2,y] in pos_outliers:
            continue
        pos_outliers.append([x1,y])
        pos_outliers.append([x2,y])
    return sorted(pos_outliers)
        
        
def solution(rectangle, characterX, characterY, itemX, itemY):
    answer = 0
    field = [[0 for _ in range(51*2)] for k in range(51*2)]
    #인접 행렬
    characterX, characterY = characterX*2 , characterY*2
    itemX, itemY = itemX*2 , itemY*2
    #1.각 직사각형 칸 획득
    for k in range(len(rectangle)):
        #outlier 칸 찾기
        x1,y1 ,x2 ,y2 = rectangle[k]
        x1 = x1*2 ; x2 = x2*2 ; y1 = y1*2 ; y2 = y2*2 # 2배 
        outliers = get_outlier(x1,y1,x2,y2)
        
        #필터링
        # 모든 변 = 1  - 영역 겹치는 모서리만 =0
        for i in range(len(outliers)):
            out_x , out_y= outliers[i]
            field[out_x][out_y] = 1 
        # 영역 겹치는 모서리 탐색 -> =0 
        for j in range(len(rectangle)) : 
            if j == k : # 본인껀 스킵
                continue
            fil_x1 , fil_y1 , fil_x2 , fil_y2 =  rectangle[j]
            fil_x1 , fil_y1  =fil_x1*2 , fil_y1*2
            fil_x2 , fil_y2  = fil_x2*2 , fil_y2*2 
            for i in range(len(outliers)):
                out_x , out_y = outliers[i]
                # 면적이 겹침 -> 필터링
                if fil_x2 > out_x > fil_x1 and fil_y2 > out_y > fil_y1: 
                    field[out_x][out_y] = 0 
        
        # for i in range(51):
        #     for k in range(51):
        #         if field[i][k] == 1:
        #             print (f"[{i},{k}")

    # stage 2. BFS로 최단 거리 찾기
    # 상하좌우
    dx =[0,0,1,-1]
    dy= [1,-1,0,0]
    queue = deque([(characterX,characterY)]) #queue 초기화
    field[characterX][characterY]=0
    while queue : 
        cur_x, cur_y = queue.popleft()
        #인접 노드
        for idx in range(4):
            # 루트만 가능
            next_x ,next_y = cur_x + dx[idx] , cur_y + dy[idx]
            if field[next_x][next_y] == 1   : # 방문 x & 길
                field[next_x][next_y] = field[cur_x][cur_y] +1 
                # print(f"#{field[next_x][next_y]}")
                if next_x == itemX and next_y == itemY: # 목적지 도착 -> 결과 반환
                    # print(f"#####{field[next_x][next_y]}")
                    return field[next_x][next_y]//2
                    break
                queue.append((next_x,next_y))
                
        # print(f"#: {cur_x},{cur_y} => {field[cur_x][cur_y]}")
        
        # print(f">{queue}")
        # print(f"##{field[next_x][next_y]}")
    
    
    return answer

# 최소 편집 거리 =1 확인
def check_edit1(a,b):
    diff= 0 
    for i in range(len(a)) :
        if a[i] != b[i] :
            diff+=1
        if diff > 1 : 
            return False
    if diff == 1 : 
        return True
        
from collections import deque
def solution(begin, target, words):
    answer = 0
    #excep1 :words 에 target없으면 -> 변환 불가
    if target not in words :
        return 0 
    
    # 1. 인접 graph 생성
    graph = [[] for _ in range(len(words)+2)] 
    # begin -> words, target 단방향 
    for k in range(len(words)) :
        if check_edit1(begin, words[k]) :
            graph[0].append(k+1)
    if check_edit1(begin,target):
        graph[0].append(len(words)+1)
    # words -> wrods_1(쌍방향) , target(단방향)    
    for k in range(len(words)):
        for j in range(k ,len(words)):
            if check_edit1(words[k], words[j]):
                graph[k+1].append(j+1)
                graph[j+1].append(k+1)
        if check_edit1(words[k], target):
            graph[k+1].append(len(words)+1)

    #2.BFS 
    visited = [ 0 for _ in range(len(words)+2)]
    def bfs(visited):
        visited[0] = 0
        queue = deque()
        queue.append(0)

        while queue :
            curr_idx = queue.popleft()
            if len(graph[curr_idx]) <= 0 : # 이웃한 놈이 없는 경우 => return 0 
                return 0

            for next_idx in graph[curr_idx] : 
                if not visited[next_idx] :  

                    queue.append(next_idx)
                    visited[next_idx] = visited[curr_idx] + 1 

                if visited[-1] : #성공
                    return visited[-1]
        
        return visited[-1] 
    

from collections import deque
def solution(maps):
    n,m = len(maps) ,len(maps[0])# y길이 # x 길이 
    
    # 이동 범위 - 하,우,상,좌
    dx = [0,1 , 0,-1]
    dy = [1 , 0 , -1 , 0]
    queue = deque([(0,0)])
    visited = [[False for _ in range(m)] for k in range(n)]
    visited[0][0] = True
    #2. BFS
    while queue :
        # 현위치 
        curr_y , curr_x = queue.popleft()
        
        # 통로 확인 - 벽or 바운더리 밖이면 x 
        for i in range(4):
            next_y = curr_y + dy[i]
            next_x = curr_x + dx[i]
            # target 도착 확인 
            if next_y == n-1 and next_x == m-1 and maps[next_y][next_x] == 1:
                visited[next_y][next_x] = True
                maps[next_y][next_x] = maps[curr_y][curr_x] +1
                break
            # 바운더리 안에 있음 * 길인 경우 + 방문 등록 x 
            if 0<=next_y< n and 0<= next_x < m :
                if maps[next_y][next_x] == 1 and not visited[next_y][next_x]:
                    maps[next_y][next_x] = maps[curr_y][curr_x] +1 
                    queue.append((next_y, next_x))
                    visited[next_y][next_x] = True

          
    # 3. 최단 거리 출력
    # print(answer_list)
    if not visited[n-1][m-1]:
        return -1 
    # answer = min(answer_list)
    answer= maps[-1][-1]
    # print(answer)
    return answer

def solution(info, n, m):
    answer = 0
    #1. dp 테이블 정의
    dp = [[] for _ in range(len(info))]

    if info[0][0] < n: 
        dp[0].append((info[0][0]  , 0))
    if info[0][1]  < m :
        dp[0].append((0, info[0][1]))
    if len(dp[0]) <= 0 :
        return -1
    # print(f" # item 0 : {dp[0]}")
    for i in range(1, len(info)):
        # dp[i][k]
        for cur_a ,cur_b in dp[i-1]:
            # print(f"##cur_a ,cur_b  {cur_a},{cur_b }")
            up_a = cur_a + info[i][0]
            up_b = cur_b + info[i][1]
            if up_a < n: 
                dp[i].append((up_a , cur_b))
            if up_b < m :
                dp[i].append((cur_a , up_b))
            # print(f" # item {i} : {dp[i]}")
        if len(dp[i]) <= 0 :
            return -1
        # print(f" # item {i} : {dp[i]}")
    # A 최소값 반환 
    answer = sorted(dp[-1])[0][0]
    return answer