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).
from collections import *
al=defaultdict(int)
from bisect import *


n,l,k=map(int,input().split())
z=list(map(int,input().split()))
al=defaultdict(int)
pri=pow(10,9)+7
g=[]
for i in range(len(z)):
    g.append(z[i])
    al[z[i]]+=1
mp=[]
t1=[]
for i in al:
    mp.append([i,al[i]])
    t1.append(i)
mp.sort()
t1.sort()
dp=[[0 for i in range(k+1)] for i in range(len(mp)+1)]


for i in range(1,k+1):

    for j in range(len(mp)):

        if(i==1 and j==0):
            dp[j][i]=mp[0][1]
        elif(i==1 and j>0):
            dp[j][i]=mp[j][1]+dp[j-1][i]
        else:
            if(j==0):
                dp[j][i]=dp[j][i-1]*mp[0][1]
                dp[j][i]%=pri
            else:
                dp[j][i]=dp[j][i-1]*mp[j][1]
                dp[j][i]%=pri
                dp[j][i]+=dp[j-1][i]
                dp[j][i]%=pri




total=0
blocks=l//len(z)
for i in range(1,k+1):
    total+=dp[len(mp)-1][i]*max(0,blocks-i+1)
    if(blocks-i+1<0):
        break;
    total%=pri
    
if(blocks==0):
    print(l)
    exit(0)


for i in range(l%n):
    t=bisect_left(t1,z[i])

    for j in range(1,k+1):
        if(j==1):
            total+=1
            continue;
        if(blocks>=j-1):
            
            total+=dp[t][j-1]
            total%=pri
        else:
            break;

print(total%pri)


    
            
    
        
