#include<stdio.h>
#include<cmath>
#include<math.h>
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<complex>
#include<queue>
#include<set>
#include<utility>
#include<iomanip>
#include<limits>
#include<thread>
#include<map>
#include<stack>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<tuple>

using namespace std;

template <class... A>
void prints() { cout << "\n"; }
template <class... A>
void prints_rest() { cout << "\n"; }
template <class T, class... A>
void prints_rest(const T &first, const A &... rest) { cout << " " << first; prints_rest(rest...); }
template <class T, class... A>
void prints(const T &first, const A &... rest) { cout << first; prints_rest(rest...); }

#define rep(i,n) for(int i=0; i<n; i++)
#define rep1(i,n) for(int i=1; i<n+1; i++)
#define repr(i,n) for(int i=n-1; i>=0; i--)
#define repr1(i,n) for(int i=n; i>0; i--)
#define souatari rep1(i,n-1)rep(j,i)
#define souatari1 for(int i=2; i<n+1; i++)rep1(j,i-1)
#define mp make_pair
#define F first
#define S second
#define elif else if

typedef long long ll;
typedef vector<int>  vi;
typedef vector<vi>  vvi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef long double D;
typedef string str;


const ll llinf =  numeric_limits<ll>::max();
const ll _llinf = numeric_limits<ll>::lowest();
const int inf = numeric_limits<int>::max();
const int _inf = numeric_limits<int>::lowest();
const double dinf = numeric_limits<double>::infinity();
const ll MOD = 1000000007;

template <unsigned P>
struct ModInt
{
    using M = ModInt;
    unsigned v;
    ModInt() : v(0) {}
    ModInt(auto x) : v(x >= 0 ? x % P : (P - -x % P) % P) {}
    constexpr ModInt(unsigned v, int) : v(v) {}
    static constexpr unsigned p() { return P; }
    M operator+() const { return *this; }
    M operator-() const { return {v ? P - v : 0, 0}; }
    explicit operator bool() const noexcept { return v; }
    bool operator!() const noexcept { return !(bool)*this; }
    M operator*(M r) const { return M(*this) *= r; }
    M operator/(M r) const { return M(*this) /= r; }
    M operator+(M r) const { return M(*this) += r; }
    M operator-(M r) const { return M(*this) -= r; }
    bool operator==(M r) const { return v == r.v; }
    bool operator!=(M r) const { return !(*this == r); }
    M &operator*=(M r)
    {
        v = (uint64_t)v * r.v % P;
        return *this;
    }
    M &operator/=(M r) { return *this *= r.inv(); }
    M &operator+=(M r)
    {
        if ((v += r.v) >= P)
            v -= P;
        return *this;
    }
    M &operator-=(M r)
    {
        if ((v += P - r.v) >= P)
            v -= P;
        return *this;
    }
    M inv() const
    {
        int a = v, b = P, x = 1, u = 0;
        while (b)
        {
            int q = a / b;
            swap(a -= q * b, b);
            swap(x -= q * u, u);
        }
        assert(a == 1);
        return x;
    }
    M pow(auto n) const
    {
        if (n < 0)
            return pow(-n).inv();
        M res = 1;
        for (M a = *this; n; a *= a, n >>= 1)
            if (n & 1)
                res *= a;
        return res;
    }
    friend M operator*(auto l, M r) { return M(l) *= r; }
    friend M operator/(auto l, M r) { return M(l) /= r; }
    friend M operator+(auto l, M r) { return M(l) += r; }
    friend M operator-(auto l, M r) { return M(l) -= r; }
    friend ostream &operator<<(ostream &os, M r) { return os << r.v; }
    friend istream &operator>>(istream &is, M &r)
    {
        ll x;
        is >> x;
        r = x;
        return is;
    }
    friend bool operator==(auto l, M r) { return M(l) == r; }
    friend bool operator!=(auto l, M r) { return !(l == r); }
};

//BIT bit(16384);みたいな感じで生成する
struct BIT {
  typedef int T;
  T n;
  vector<T> bit;

  // 各要素の初期値は 0
  BIT(T num) : bit(num+1, 0) { n = num; }

  // a_i += w
  void add(T i, T w) {
    for (T x = i; x <= n; x += x & -x) {
      bit[x] += w;
    }
  }

  // [1, i] の和を計算.
  T sum(T i) {
    T ret = 0;
    for (T x = i; x > 0; x -= x & -x) {
      ret += bit[x];
    }
    return ret;
  }

  //[iより大きい]の和を計算
  T sum_above(T i) {
    T ret = 0;
    for (T x = i; x > 0; x -= x & -x) {
      ret += bit[x];
    }
    return sum(n) - ret;
  }

};




int alist[2005];
BIT bit(2005);
int a[2005];
BIT abit(2005);

int main(){ 

  int n,k;
  cin >> n >> k;
  rep(i,n) cin >> a[i];

  int tentou = 0;
  rep(i,n){
    alist[a[i]]++;
    bit.add(a[i],1);
    tentou += bit.sum_above(a[i]);
  }

  ll ktmp = k%2 == 0 ? k / 2 : k;
  ll ktmp1 = (k-1)%2 == 0 ? (k-1) / 2 : k-1;


  ll bigger = 0;
  rep(i,2003){
    int tmp = 0;
    for(int j = i+1; j < 2003 ; j++){
      tmp += alist[j];
    }
    ll bigtmp = tmp * alist[i];
    bigger += bigtmp;
  }


  ModInt<MOD> ans = 0;

  ans = k;
  ans *= tentou;


  ModInt<MOD> b = 0;
  b = bigger;
  b *= ktmp;
  b *= ktmp1;

  ans += b;

  prints(ans);


  return 0;

}


Measured memory_bytes: 256