While Duff was resting in the beach, she accidentally found a strange array *b*<sub class="lower-index">0</sub>, *b*<sub class="lower-index">1</sub>, ..., *b*<sub class="lower-index">*l* - 1</sub> consisting of *l* positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, *a*<sub class="lower-index">0</sub>, ..., *a*<sub class="lower-index">*n* - 1</sub> that *b* can be build from *a* with formula: *b*<sub class="lower-index">*i*</sub> = *a*<sub class="lower-index">*i* *mod* *n*</sub> where *a* *mod* *b* denoted the remainder of dividing *a* by *b*.

Duff is so curious, she wants to know the number of subsequences of *b* like *b*<sub class="lower-index">*i*<sub class="lower-index">1</sub></sub>, *b*<sub class="lower-index">*i*<sub class="lower-index">2</sub></sub>, ..., *b*<sub class="lower-index">*i*<sub class="lower-index">*x*</sub></sub> (0 ≤ *i*<sub class="lower-index">1</sub> &lt; *i*<sub class="lower-index">2</sub> &lt; ... &lt; *i*<sub class="lower-index">*x*</sub> &lt; *l*), such that: 
 -  1 ≤ *x* ≤ *k* -  For each 1 ≤ *j* ≤ *x* - 1, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/8049e70898b1d8579ee1e94f4c68483c301ddfc5.png" style="max-width: 100.0%;max-height: 100.0%;"/> -  For each 1 ≤ *j* ≤ *x* - 1, *b*<sub class="lower-index">*i*<sub class="lower-index">*j*</sub></sub> ≤ *b*<sub class="lower-index">*i*<sub class="lower-index">*j* + 1</sub></sub>. i.e this subsequence is non-decreasing. 
Since this number can be very large, she want to know it modulo 10<sup class="upper-index">9</sup> + 7.

Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
The first line of input contains three integers, *n*, *l* and *k* (1 ≤ *n*, *k*, *n* × *k* ≤ 10<sup class="upper-index">6</sup> and 1 ≤ *l* ≤ 10<sup class="upper-index">18</sup>).

The second line contains *n* space separated integers, *a*<sub class="lower-index">0</sub>, *a*<sub class="lower-index">1</sub>, ..., *a*<sub class="lower-index">*n* - 1</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup> for each 0 ≤ *i* ≤ *n* - 1).
import sys
readline = sys.stdin.readline

MOD = 10**9+7
def frac(limit):
    frac = [1]*limit
    for i in range(2,limit):
        frac[i] = i * frac[i-1]%MOD
    fraci = [None]*limit
    fraci[-1] = pow(frac[-1], MOD -2, MOD)
    for i in range(-2, -limit-1, -1):
        fraci[i] = fraci[i+1] * (limit + i + 1) % MOD
    return frac, fraci
frac, fraci = frac(2341398)
def comb(a, b):
    if not a >= b >= 0:
        return 0
    return frac[a]*fraci[b]*fraci[a-b]%MOD

def compress(L):
    L2 = list(set(L))
    L2.sort()
    C = {v : k for k, v in enumerate(L2)}
    return L2, C

N, L, K = map(int, readline().split())
A = list(map(int, readline().split()))
_, Ca = compress(A)
A = [Ca[a] for a in A]
dp1 = [1]*N

R = (L//N)
if N <= L:
    ans = R*N
else:
    ans = 0

D = [1]*N
for r in range(2, min(R, K)+1):
    da = [0]*N
    for j in range(N):
        a = A[j]
        da[a] = (da[a] + dp1[j])%MOD
    for a in range(1, N):
        da[a] = (da[a] + da[a-1])%MOD 
    for j in range(N):
        a = A[j]
        dp1[j] = da[a]

    for i in range(N):
        d1 = dp1[i]
        c = comb(R, r)*d1%MOD
        ans = (ans + c)%MOD
        if r < K:
            D[i] = (D[i] + c)%MOD

da = [0]*N
for j in range(N):
    a = A[j]
    da[a] = (da[a] + D[j])%MOD
for a in range(1, N):
    da[a] = (da[a] + da[a-1])%MOD 
for j in range(L%N):
    a = A[j]
    ans = (ans+da[a])%MOD
    
ans = (ans + L%N)%MOD    

print(ans)
        
    
