// Original C++ solution (slower):
#include<iostream>

#include<vector>

#include<string>

#include<algorithm>

#include<utility>

#include<cmath>

#include<climits>

#include<queue>

#include<stack>

#include<numeric>

#include<set>

#include<iomanip>

#include<map>

#include<type_traits>

#include<tuple>

#include<deque>

#include<cassert>

using namespace std;

typedef long long ll;

typedef pair<int,int> P;

#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)

const int mod = 1000000007;



struct mint {

  ll x; // typedef long long ll;

  mint(ll x=0):x((x%mod+mod)%mod){}

  mint operator-() const { return mint(-x);}

  mint& operator+=(const mint a) {

    if ((x += a.x) >= mod) x -= mod;

    return *this;

  }

  mint& operator-=(const mint a) {

    if ((x += mod-a.x) >= mod) x -= mod;

    return *this;

  }

  mint& operator*=(const mint a) {

    (x *= a.x) %= mod;

    return *this;

  }

  mint operator+(const mint a) const {

    mint res(*this);

    return res+=a;

  }

  mint operator-(const mint a) const {

    mint res(*this);

    return res-=a;

  }

  mint operator*(const mint a) const {

    mint res(*this);

    return res*=a;

  }

  mint pow(ll t) const {

    if (!t) return 1;

    mint a = pow(t>>1);

    a *= a;

    if (t&1) a *= *this;

    return a;

  }



  // for prime mod

  mint inv() const {

    return pow(mod-2);

  }

  mint& operator/=(const mint a) {

    return (*this) *= a.inv();

  }

  mint operator/(const mint a) const {

    mint res(*this);

    return res/=a;

  }

};



struct combination {

  vector<mint> fact, ifact;

  combination(int n):fact(n+1),ifact(n+1) {

    assert(n < mod);

    fact[0] = 1;

    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;

    ifact[n] = fact[n].inv();

    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;

  }

  mint operator()(int n, int k) {

    if (k < 0 || k > n) return 0;

    return fact[n]*ifact[k]*ifact[n-k];

  }

};



int main(){

  int n, k;

  cin >> n >> k;

  vector<int> a(n);

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

  sort(a.begin(), a.end());

  mint ans = 0;

  combination c(100100);

  rep(ri, 2) {

    mint s = 0;

    for(int i = 0; i < n; ++i){

      s += c(i, k - 1) * a[i];

    }

    if(ri % 2 == 0) ans += s;

    else ans -= s;



    reverse(a.begin(), a.end());

  }

  cout << ans.x << endl;

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<vector>

#include<string>

#include<algorithm>

#include<utility>

#include<cmath>

#include<climits>

#include<queue>

#include<stack>

#include<numeric>

#include<set>

#include<iomanip>

#include<map>

#include<type_traits>

#include<tuple>

#include<deque>

#include<cassert>

using namespace std;

typedef long long ll;

typedef pair<ll,int> p;

#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)

const int mod = 1000000007;

const int INF = 1001001001;



struct mint {

  ll x; // typedef long long ll;

  mint(ll x=0):x((x%mod+mod)%mod){}

  mint operator-() const { return mint(-x);}

  mint& operator+=(const mint a) {

    if ((x += a.x) >= mod) x -= mod;

    return *this;

  }

  mint& operator-=(const mint a) {

    if ((x += mod-a.x) >= mod) x -= mod;

    return *this;

  }

  mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}

  mint operator+(const mint a) const { return mint(*this) += a;}

  mint operator-(const mint a) const { return mint(*this) -= a;}

  mint operator*(const mint a) const { return mint(*this) *= a;}

  mint pow(ll t) const {

    if (!t) return 1;

    mint a = pow(t>>1);

    a *= a;

    if (t&1) a *= *this;

    return a;

  }



  // for prime mod

  mint inv() const { return pow(mod-2);}

  mint& operator/=(const mint a) { return *this *= a.inv();}

  mint operator/(const mint a) const { return mint(*this) /= a;}

};

istream& operator>>(istream& is, const mint& a) { return is >> a.x;}

ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}



struct combination {

  vector<mint> fact, ifact;

  combination(int n):fact(n+1),ifact(n+1) {

    assert(n < mod);

    fact[0] = 1;

    for (int i = 1; i <= n; ++i) fact[i] = fact[i-1]*i;

    ifact[n] = fact[n].inv();

    for (int i = n; i >= 1; --i) ifact[i-1] = ifact[i]*i;

  }

  mint operator()(int n, int k) {

    if (k < 0 || k > n) return 0;

    return fact[n]*ifact[k]*ifact[n-k];

  }

};



int main() {

  int n, k;

  cin >> n >> k;

  vector<int> a(n);

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

  sort(a.begin(), a.end());

  combination comb(n);

  mint ans = 0;

  rep(ii, 2) {

    mint s = 0;

    rep(i, n) {

      s +=  comb(i, k - 1) * a[i];

    }

    reverse(a.begin(), a.end());

    if(ii == 0) ans += s;

    else ans -= s;

  }

  cout << ans << endl;

}


// Fastest known solution for this problem: