#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
#define EPS (1e-9)
#define INF (1e9)
#define INFL (1e18)
#define MOD (1000000007)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = (n - 1); i >= 0; --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
#define BIT(n) (1LL << (n))
// ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
// param > 0 => use param as the modulo
// param <= 0 => you can set the modulo with ModInt<param>::set_modulo(...) in
// runtime. Of course, those runtime modulo will be distinguished if the param
// was different.
template <int param> class ModInt { //{{{
    using Z = int;
    using N = unsigned int;
    using ZZ = long long;
    using NN = unsigned long long;
    struct {
    } constexpr static exact{};

    // Using Z deliberately to avoid Z -> N promotion.
    template <class Ret = Z &>
    static auto modulo() -> std::enable_if_t<(param <= 0), Ret> {
        static Z mod = 0;
        return mod;
    }
    template <class Ret = const Z>
    static auto mod() -> std::enable_if_t<(param <= 0), Ret> {
        return modulo();
    }
    template <class Ret = const Z>
    static constexpr auto mod() -> std::enable_if_t<(param > 0), Ret> {
        return param;
    }
    // std::swap is not a constexpr function in C++14
    static constexpr void swap(Z &a, Z &b) {
        Z tmp = a;
        a = b;
        b = tmp;
    }

    Z val;
    constexpr ModInt(decltype(exact), const N v) : val(v) {}

  public:
    template <class Arg = Z>
    static void set_modulo(const std::enable_if_t<(param <= 0), Arg> mod) {
        modulo() = mod;
    }

    constexpr ModInt() : val(0) {}
    constexpr ModInt(Z v) : val((v %= mod()) < 0 ? v + mod() : v) {}
    constexpr ModInt(ZZ v) : val((v %= mod()) < 0 ? v + mod() : v) {}

    constexpr int get_val() const { return val; }

    constexpr ModInt inv() const {
        Z a = mod(), b = val;
        Z x = 0, u = 1;
        while (b) {
            const Z t = a / b;
            swap(a -= t * b, b);
            swap(x -= t * u, u);
        }
        return ModInt(exact, x < 0 ? x + mod() : x);
    }

    constexpr explicit operator int() const { return val; }
    constexpr ModInt operator+() const { return *this; }
    constexpr ModInt operator-() const {
        return ModInt(exact, val ? mod() - val : 0);
    }

    constexpr ModInt operator++() {
        if (++val == mod())
            val = 0;
        return *this;
    }
    constexpr ModInt operator--() {
        val = (val == 0 ? mod() - 1 : val - 1);
        return *this;
    }
    constexpr ModInt operator++(int) {
        const ModInt res(*this);
        ++*this;
        return res;
    }
    constexpr ModInt operator--(int) {
        const ModInt res(*this);
        --*this;
        return res;
    }

    constexpr bool operator==(const ModInt &rhs) const {
        return val == rhs.val;
    }
    constexpr bool operator!=(const ModInt &rhs) const {
        return val != rhs.val;
    }
    constexpr ModInt &operator+=(const ModInt &rhs) {
        if ((val += rhs.val) >= mod())
            val -= mod();
        return *this;
    }
    constexpr ModInt &operator-=(const ModInt &rhs) {
        if (rhs.val && (val += mod() - rhs.val) >= mod())
            val -= mod();
        return *this;
    }
    constexpr ModInt &operator*=(const ModInt &rhs) {
        val = (NN)(val)*rhs.val % mod();
        return *this;
    }
    constexpr ModInt &operator/=(const ModInt &rhs) {
        return *this *= rhs.inv();
    }

    constexpr ModInt pow(long long e) const {
        if (e < 0)
            return pow(-e).inv();
        NN res = 1, b = val;
        for (; e; e >>= 1, (b *= b) %= mod())
            if (e & 1)
                (res *= b) %= mod();
        return ModInt(exact, res);
    }
    friend constexpr ModInt operator+(ModInt lhs, const ModInt &rhs) {
        return lhs += rhs;
    }
    friend constexpr ModInt operator-(ModInt lhs, const ModInt &rhs) {
        return lhs -= rhs;
    }
    friend constexpr ModInt operator*(ModInt lhs, const ModInt &rhs) {
        return lhs *= rhs;
    }
    friend constexpr ModInt operator/(ModInt lhs, const ModInt &rhs) {
        return lhs /= rhs;
    }

    friend std::ostream &operator<<(std::ostream &os, const ModInt &v) {
        return os << v.val;
    }
    friend std::istream &operator>>(std::istream &is, ModInt &v) {
        int val;
        is >> val;
        v = ModInt(val);
        return is;
    }
}; //}}}

using mint = ModInt<MOD>;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    ll n, k;
    cin >> n >> k;
    vector<int> v(n);
    map<int, int> mp;
    mint ans = 0;
    REP(i, n) cin >> v[i];
    REP(i, n) {
        FOR(j, i + 1, n) {
            if (v[i] > v[j]) {
                ans += (k + 1) * k / 2;
            } else if (v[i] < v[j]) {
                ans += (k - 1) * k / 2;
            }
        }
    }
    cout << ans << endl;

    return 0;
}


Measured memory_bytes: 256