## https://yukicoder.me/problems/no/286

MOD = 10 ** 9 + 7

def prod_vector(matrix, vector):
    n = len(matrix)
    new_vector = [0] * n
    for i in range(n):
        for j in range(n):
            new_vector[i] += (matrix[i][j] * vector[j]) % MOD
            new_vector[i] %= MOD
    return new_vector

def prod_matrix(left, right):
    n = len(left)
    new_matrix = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            for k in range(n):
                new_matrix[i][j] += (left[i][k] * right[k][j]) % MOD
                new_matrix[i][j] %= MOD
    return new_matrix

def main():
    N, W, K = map(int, input().split())
    A = list(map(int, input().split()))

    # matrixの計算

    matrix = [[0] * (2 * (W + 1)) for _ in range(2 * (W + 1))]

    for start_d in range(W):
        for start_state in range(2):
            if start_d == 0 and start_state == 1:
                continue

            dp = [[0] * (2 * W + 1) for _ in range(2)]
            dp[start_state][start_d] = 1

            for w in range(start_d, W):
                # state = 0
                for a in A:
                    if w + a < W:
                        dp[0][w + a] += dp[0][w]
                        dp[0][w + a] %= MOD
                    elif w + a == W or w + a == 2 * W:
                        dp[0][w + a] += dp[0][w]
                        dp[0][w + a] %= MOD
                    elif W < w + a < 2 * W:
                        dp[1][w + a] += dp[0][w]
                        dp[1][w + a] %= MOD
                
                # state = 1
                for a in A:
                    if w + a < W:
                        dp[1][w + a] += dp[1][w]
                        dp[1][w + a] %= MOD
                    elif w + a == W:
                        dp[0][w + a] += dp[1][w]
                        dp[0][w + a] %= MOD
            
            from_i = (W + 1) * start_state + start_d
            for to_i in range(2 * (W + 1)):
                state = to_i // (W + 1)
                w = to_i % (W + 1)
                matrix[to_i][from_i] = dp[state][w + W]
    matrix[0][W] = 1

    vector = [0] * (2 * (W + 1))
    vector[0] = 1
    K0 = K - 1    
    while K0 > 0:
        if K0 % 2 == 1:
            vector = prod_vector(matrix, vector)
        
        matrix = prod_matrix(matrix, matrix)
        K0 //= 2

    # 最後のdp
    dp = [0] * (W + 1)
    for i in range(2 * (W + 1)):
        w = i % (W + 1)
        dp[w] += vector[i]
        dp[w] %= MOD

    for j in range(W + 1):
        for a in A:
            if j + a <= W:
                dp[j + a] += dp[j]
                dp[j + a] %= MOD
    
    print(dp[-1])



            





if __name__ == '__main__':
    main()