#include <iostream>
#include <climits>
#include <cstdio>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <queue>
#include <iomanip>
#include <cassert>
using namespace std;

typedef long long ll;

typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;

#define fo(y) for(ll i=0,i<y; i++)
#define fl(i,x,y) for(ll i=x; i<y; i++)
#define Sort(v) sort(v.begin(),v.end())
#define pr(x) cout<<x<<"\n"

#define pb push_back
#define rem(v,x) remove(v.begin(),v.end(),x)

#define INF 1000000000000000
ll MOD = 1000000007;
const int Max = 200010;
ll MIN(ll x,ll y){if(x>y){return y;}else{return x;}}
ll MAX(ll x,ll y){if(y>x){return y;}else{return x;}}
// typedef struct st
// {
//         vector<int> group;
//         struct st* left;
//         struct st* right;
// } Node;
// ll fac[2001]; ll ifac[2001]; 
// typedef struct st
// {
//         vector<int> group;
//         struct st* left;
//         struct st* right;
// } Node;
// ll fac[2001]; ll ifac[2001]; 
// vll graph[Max];vector<ll> vis(Max,0),result(Max,0);
// //ll conn;ll input_array[MAX]; ll rmq_tree[2*MAX];
// ll gcd(ll a, ll b){
//         if(a == 0)return b; else return gcd(b % a, a);}
// ll dfs(ll v,vector<ll> vis)
// {
//         vis[v] = 1;
//         ll depth=0;
//         for (ll i=0; i<graph[v].size(); i++)
//         {
//                 //cout<<v<<" "<<graph[v][i]<<"\n";
//                 if (vis[graph[v][i]]==0)
//                 {
//                     result[v]=dfs(graph[v][i],vis);
//                     return result[v];
//                 }
//                 else 
//                 {
//                     vis[v]=0;
//                     result[graph[v][i]]=graph[v][i];
//                     return graph[v][i];
//                 }
//         }
//         return -10;
// }
// ll bfs(ll u) 
// { 
//     ll ans=0;
//     ll i;
//     queue<int> q; 
//     q.push(u); 
//     vis[u] = true; 
//     while (!q.empty()) 
//     { 
//         ll v = q.front(); 
//         q.pop(); 
//         ll j=0;
//         for (i=0; i<graph[v].size(); i++)
//         {
//             if (vis[graph[v][i]]==false)
//             {
//                 //cout<<v<<" "<<graph[v][i]<<"\n";
//                 q.push(graph[v][i]);
//                 vis[graph[v][i]]=true;
//             }
//             else if(graph[graph[v][i]][0]!=v)
//             {
//                 return 1;
//             }
//         }
        
//         // Enqueue all adjacent of f and mark them visited 
//     }
//     return 0;
// } 
 
/* Iterative Function to calculate (x^y)%p in O(log y) */
// ll power(ll x, ll y, ll p){
//         ll res = 1;
//
//         x = x % p;
//
//         while (y > 0)
//         {
//                 if (y & 1)
//                         res = (res*x) % p;
//                 y = y>>1;
//                 x = (x*x) % p;
//         }
//         return res;
// }
// int modInverse(ll n, ll p){
//         return power(n, p-2, p);
// }
// void factorial(){
//         fac[0] = 1;
//         for (int i=1; i<=2000; i++)
//                 fac[i] = fac[i-1]*i%MOD;
// }
// void ifactorial(){
//         for (int i=0; i<=2000; i++)
//                 ifac[i] = modInverse(fac[i], MOD) % MOD;
// }
// ll nCrModPFermat(ll n, ll r, ll p){
//         if (r==0)
//                 return 1;
//         return ((((fac[n]* ifac[r]) % p)*(ifac[n-r] % p)) % p);
// }
// int checkprime(ll num)
// {
//         for(ll i=2; i*i<=num; i++)
//         {
//                 if(num%i==0)
//                 {
//                         return 0;
//                 }
//         }
//         return 1;
// }
// ll query(int index,int s,int e,int qs,int qe){
//         //base case: if query range is outside the node range
//         if(qs>e || s>qe)
//                 return -1;
//         //complete overlap
//         if(s>=qs && e<=qe)
//                 return rmq_tree[index];
//         //now partial overlap case is executed
//         int m = (s+e)/2;
//         ll left_ans = query(2*index,s,m,qs,qe);
//         ll right_ans = query(2*index+1,m+1,e,qs,qe);
//         return max(left_ans,right_ans);
// }
// void buildTree(int index,int s,int e){
//         if(s>e)
//                 return;
//         if(s==e)
//         {
//                 rmq_tree[index]=input_array[s];
//                 return;
//         }
//         int m = (s+e)/2;
//         buildTree(2*index,s,m);
//         buildTree(2*index+1,m+1,e);
//         rmq_tree[index]= max(rmq_tree[2*index],rmq_tree[2*index+1]);
//         return;
// }
// void rmq(int s,int e){
//         buildTree(1,s,e);
//}
// cin>>n;
//         while(i<n)
//         {   
//             cin>>x;
//             graph[i+1].pb(x);
//             i++;
//         }
//         i=0;
//         while(i<n)
//         {
//             if(result[i+1]==0)
//             {
//                 vector<ll> vis(Max,0);
//                 dfs(i+1,vis);
//             }
//             cout<<result[i+1]<<" ";
//             i++;
//        
vector< vector<ll> >graph[Max];vector<ll> vis(Max,0),result(Max,0);
int main()
{
    //----------------------------------------------------------------------------------
    int t = 1; ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cout.precision(8); cout << fixed;
    //cin >> t;
    //clock_t begin = clock();
    // factorial();
    // ifactorial();
    //-----------------------------------------------------------------------------------
    while (t--)
    {
        //------------------------------------------------------------------------------------
        ll i = 0, j = 0, k = 0, n = 0, m = 0, x = 0, sum = 0, res = 0, p = 0, q = 0, l = 0, r = 0, d = 0, a = 0, b = 0, count = 0, max = 0, z = 0;
        double ans = 0,a1,b1;
        string s1,s2;
        set<ll>ss, se;
        vll v1,v2,v3,v4;
        map< ll,ll >mp1,mp2;
        //-------------------------------------------------------------------------------------------------------------------
        cin>>n>>m;
        while(i<n)
        {
        	cin>>x;
        	v1.pb(x);
        	i++;
        }
        for(i=0;i<n;i++)
        {
        	p=0;q=0;
        	for(j=0;j<i;j++)
        	{
        		if(v1[i]>v1[j])
        		{
        			p++;
        		}
        	}
        	for(k=i+1;k<n;k++)
        	{
        		if(v1[i]>v1[k])
        		{
        			q++;
        		}
        	}
        	v2.pb(p);
        	v3.pb(q);
			v4.pb(p+q);
        }
        if(m%2==0)
        {
        	p=m/2;
        }
        else
        {
        	p=(m+1)/2;
        	q=(m-1)/2;
        }
        for(i=0;i<n;i++)
        {

        	if(m%2==0)
        	{
        		sum=sum+((v3[i]*p)%MOD * (m+1))%MOD;
        		sum=sum%MOD;
        		sum=sum+((v2[i]*p)%MOD * (m-1))%MOD;
        		sum=sum%MOD;
        	}
        	else
        	{

        		sum=sum+((v3[i]*p)%MOD * (m))%MOD;
        		sum=sum%MOD;
        		sum=sum+((v2[i]*q)%MOD * (m))%MOD;
        		sum=sum%MOD;
        	}
        }
        pr(sum);
	}
    // clock_t end = clock();
    // double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    // pr(elapsed_secs);
    return 0;
}

Measured memory_bytes: 8192