import java.io._
import java.util.StringTokenizer

import scala.reflect.ClassTag

object Main {
  def main(args: Array[String]): Unit = {
    try {
      val (in, out) =
        if (isOnlineJudge) {
          (
            new FastScanner(new InputStreamReader(System.in)),
            new PrintWriter(System.out)
          )
        } else {
          (
            new FastScanner(new FileReader(new File("src/resource/problem.in"))),
            new PrintWriter(new File("src/resource/problem.out"))
          )
        }
      new Abc151(in, out).solve()
      out.flush()
      out.close()
    } catch {
      case e: IOException => e.printStackTrace()
    }
  }

  private[this] val isOnlineJudge = true

  class FastScanner(val streamReader: InputStreamReader) {
    private[this] val reader = new BufferedReader(streamReader, 32768)
    private[this] var tokenizer: StringTokenizer = _

    @inline private[this] final def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = Integer.parseInt(next())

    def nextLong(): Long = java.lang.Long.parseLong(next())

    def nextChar(): Char = next().charAt(0)

    def ni(): Int = nextInt()

    def nl(): Long = nextLong()

    def nc(): Char = nextChar()

    def ns(): String = next()

    def ns(n: Int): Array[Char] = ns().toCharArray

    def na(n: Int, offset: Int = 0): Array[Int] = map(n)(_ => ni() + offset)

    def na2(n: Int, offset: Int = 0): (Array[Int], Array[Int]) = {
      val A1, A2 = Array.ofDim[Int](n)
      REP(n) { i =>
        A1(i) = ni() + offset
        A2(i) = ni() + offset
      }
      (A1, A2)
    }

    def nm(n: Int, m: Int): Array[Array[Int]] = {
      val A = Array.ofDim[Int](n, m)
      REP(n) { i =>
        REP(m) { j =>
          A(i)(j) = ni()
        }
      }
      A
    }

    def nal(n: Int): Array[Long] = map(n)(_ => nl())

    def nm_c(n: Int, m: Int): Array[Array[Char]] = map(n)(_ => ns(m))
  }

  def REP(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = offset
    val N = n + offset
    while (i < N) {
      f(i);
      i += 1
    }
  }

  def REP_r(n: Int, offset: Int = 0)(f: Int => Unit): Unit = {
    var i = n - 1 + offset
    while (i >= offset) {
      f(i);
      i -= 1
    }
  }

  def TO(from: Int, to: Int)(f: Int => Unit): Unit = {
    REP(to - from + 1, from)(f)
  }

  def map[@specialized A: ClassTag](n: Int, offset: Int = 0)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    REP(n)(i => res(i) = f(i + offset))
    res
  }

  def sumL(as: Array[Int]): Long = {
    var s = 0L
    REP(as.length)(i => s += as(i))
    s
  }

  def cumSum(as: Array[Int]): Array[Long] = {
    val cum = Array.ofDim[Long](as.length + 1)
    REP(as.length) { i =>
      cum(i + 1) = cum(i) + as(i)
    }
    cum
  }
}

class Abc151(fScanner: Main.FastScanner, out: java.io.PrintWriter) {

  import Main._
  import fScanner._

  def solve(): Unit = {
    val n = ni()
    val k = ni()
    preCompute(n)
    val a = Array.ofDim[Int](n+1)
    a(0) = Int.MinValue
    REP(n, 1) { i => a(i) = ni() }
    scala.util.Sorting.quickSort(a)
    var ans = 0L
    k to n foreach { i =>
      ans += a(i) * nCr(i-1, k-1)
      ans = (ans % MOD + MOD) % MOD
    }

    1 to n-k+1 foreach { i =>
      ans -= a(i) * nCr(n-i, k-1)
      ans = (ans % MOD + MOD) % MOD
    }

    out.println(ans)
  }

  var fact: Array[Long] = _
  var invfact: Array[Long] = _
  val MOD: Int = (1e9 + 7).toInt

  def preCompute(N: Int) = {
    fact = Array.ofDim[Long](N+5)
    invfact = Array.ofDim[Long](N+5)

    fact(0) = 1
    fact(1) = 1

    REP(N, 2) { i =>
      fact(i) = i * fact(i-1)
      fact(i) %= MOD
    }

    invfact(N+1) = modInv(fact(N+1))
    REP_r(N+1) { i =>
      invfact(i) = invfact(i+1) * (i+1)
      invfact(i) %= MOD
    }
  }

  def nCr(u: Int, v: Int): Long = {
    if(v > u) 0
    else {
      var ans = fact(u)
      ans *= invfact(v)
      ans %= MOD
      ans *= invfact(u-v)
      ans %= MOD
      ans
    }
  }

  def modInv(x: Long): Long = {
    pow(x, MOD-2)
  }

  def pow(u: Long, n: Int): Long = {
    var ans = 1L
    var v = n
    var ret = u.toLong
    while (v > 0) {
      if(v % 2 != 0) {
        ans = ans * ret
        ans %= MOD
      }
      ret = ret * ret
      ret %= MOD
      v /= 2
    }
    ans
  }

}


Measured memory_bytes: 44760