using System;
using System.Collections.Generic;
using System.Linq;


namespace AtCoder
{
    partial class Program
    {
        static void Main(string[] args)
        {
			//↓

            var nk = ReadIntArray();
            var n = nk[0];
            long k = nk[1];
            var aas = ReadIntArray();

            var p = 1000000000 + 7;

            var l = new List<int>();

            long r = 0;

            long kkm12, kkp12;
            if (k % 2 == 0)
            {
                kkm12 = k / 2 * (k - 1) % p;
                kkp12 = k / 2 * (k + 1) % p;
            }
            else
            {
                kkm12 = k * (k - 1) / 2 % p;
                kkp12 = k * (k + 1) / 2 % p;
            }

            for (int i = 0; i < n; i++)
            {
                var c = aas[i];

                long scount = -1;
                long lcount = -1;
                for (int j = 0; j < l.Count; j++)
                {
                    var cc = l[j];
                    if(scount < 0)
                    {
                        if (j == l.Count - 1 && cc < c)
                        {
                            scount = l.Count;
                        }
                        else if (cc >= c)
                        {
                            scount = j;
                        }
                    }
                    
                    if (cc > c)
                    {
                        lcount = l.Count - j;
                        break;
                    }
                }

                scount = Math.Max(scount, 0);
                lcount = Math.Max(lcount, 0);

                l.Insert(Math.Max((int)scount, 0), c);

                r = (r + (scount * kkm12 % p)) % p;
                r = (r + (lcount * kkp12 % p)) % p;
            }

            Console.WriteLine(r);


			//↑
        }
		static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
		
        public class PriorityQueue<T> where T : IComparable
        {
            private IComparer<T> _comparer = null;
            private int _type = 0;

            private T[] _heap;
            private int _sz = 0;

            private int _count = 0;

            /// <summary>
            /// Priority Queue with custom comparer
            /// </summary>
            public PriorityQueue(int maxSize, IComparer<T> comparer)
            {
                _heap = new T[maxSize];
                _comparer = comparer;
            }

            /// <summary>
            /// Priority queue
            /// </summary>
            /// <param name="maxSize">max size</param>
            /// <param name="type">0: asc, 1:desc</param>
            public PriorityQueue(int maxSize, int type = 0)
            {
                _heap = new T[maxSize];
                _type = type;
            }

            private int Compare(T x, T y)
            {
                if (_comparer != null) return _comparer.Compare(x, y);
                return _type == 0 ? x.CompareTo(y) : y.CompareTo(x);
            }

            public void Push(T x)
            {
                _count++;

                //node number
                var i = _sz++;

                while (i > 0)
                {
                    //parent node number
                    var p = (i - 1) / 2;

                    if (Compare(_heap[p], x) <= 0) break;

                    _heap[i] = _heap[p];
                    i = p;
                }

                _heap[i] = x;
            }

            public T Pop()
            {
                _count--;

                T ret = _heap[0];
                T x = _heap[--_sz];

                int i = 0;
                while (i * 2 + 1 < _sz)
                {
                    //children
                    int a = i * 2 + 1;
                    int b = i * 2 + 2;

                    if (b < _sz && Compare(_heap[b], _heap[a]) < 0) a = b;

                    if (Compare(_heap[a], x) >= 0) break;

                    _heap[i] = _heap[a];
                    i = a;
                }

                _heap[i] = x;

                return ret;
            }

            public int Count()
            {
                return _count;
            }

            public T Peek()
            {
                return _heap[0];
            }

            public bool Contains(T x)
            {
                for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true;
                return false;
            }

            public void Clear()
            {
                while (this.Count() > 0) this.Pop();
            }

            public IEnumerator<T> GetEnumerator()
            {
                var ret = new List<T>();

                while (this.Count() > 0)
                {
                    ret.Add(this.Pop());
                }

                foreach (var r in ret)
                {
                    this.Push(r);
                    yield return r;
                }
            }

            public T[] ToArray()
            {
                T[] array = new T[_sz];
                int i = 0;

                foreach (var r in this)
                {
                    array[i++] = r;
                }

                return array;
            }
        }
	}
}

Measured memory_bytes: 13396