import sys
MOD = 10**9 + 7

def next_permutation(arr):
    n = len(arr)
    k = n - 2
    while k >= 0 and arr[k] >= arr[k+1]:
        k -= 1
    if k == -1:
        return False
    l = n - 1
    while arr[k] >= arr[l]:
        l -= 1
    arr[k], arr[l] = arr[l], arr[k]
    arr[k+1:] = arr[k+1:][::-1]
    return True

def compute_inversion(p):
    n = len(p)
    inv = 0
    for i in range(n):
        for j in range(i+1, n):
            if p[i] > p[j]:
                inv += 1
    return inv

def main():
    N, K = map(int, sys.stdin.readline().split())
    p = list(map(int, sys.stdin.readline().split()))
    if K == 0:
        print(0)
        return
    if N == 1:
        print(0)
        return
    if N <= 20:
        current = p.copy()
        cycle = []
        visited = {}
        idx = 0
        while True:
            t = tuple(current)
            if t in visited:
                break
            visited[t] = idx
            cycle.append(current.copy())
            if not next_permutation(current):
                current = [i+1 for i in range(N)]
            idx += 1
        start = visited[tuple(p)]
        cycle_len = len(cycle) - start
        invs = [compute_inversion(perm) for perm in cycle]
        total_sum = 0
        if K <= cycle_len:
            for i in range(start, start + K):
                total_sum += invs[i % len(cycle)]
        else:
            full_cycles = K // cycle_len
            remainder = K % cycle_len
            sum_cycle = sum(invs[start:start + cycle_len])
            total_sum += full_cycles * sum_cycle
            for i in range(start, start + remainder):
                total_sum += invs[i % len(cycle)]
        print(total_sum % MOD)
    else:
        inv4 = pow(4, MOD-2, MOD)
        res = K % MOD * ((N * (N-1)) % MOD) % MOD
        res = res * inv4 % MOD
        print(res)

if __name__ == "__main__":
    main()