import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().solve();
    }

    private void solve() throws IOException {
        try {
//            solveA();
//            solveB();
//            solveC();
//            solveD();
            solveE();
            //			 solveF();
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.flush();
                out.close();
            }
        }

    }

    private void solveA() {
        char[] c = next().toCharArray();

        out.println((char) (c[0] + 1));
    }

    private void solveB() {
        int n = nextInt();
        int k = nextInt();
        int m = nextInt();
        int[] wk = IntStream.range(0, n - 1).map(i -> nextInt()).toArray();
        int diff = n * m - Arrays.stream(wk).sum();
        if (diff > k)
            out.println(-1);
        else
            out.println(diff > 0 ? diff : 0);

    }

    private static class Problem {
        int ind;
        int problem;
        int ans;

        public Problem(int ind, int problem, int ans) {
            this.ind = ind;
            this.problem = problem;
            this.ans = ans;
        }

    }

    private void solveC() {
        int n = nextInt();
        int m = nextInt();
        Problem[] problem = new Problem[m];
        for (int i = 0; i < m; i++) {
            problem[i] = new Problem(i, nextInt(), next().equals("WA") ? 0 : 1);
        }
        if (problem.length == 0) {
            out.println(0 + " " + 0);
            return;
        }
        Arrays.sort(problem, (x, y) -> Integer.compare(x.problem, y.problem) == 0 ? Integer.compare(x.ind, y.ind) : Integer.compare(x.problem, y.problem));
        Set<Integer> ac = new HashSet<Integer>();
        boolean notAc = true;
        int prev = problem[0].problem;
        Map<Integer, Integer> waMemo = new HashMap<Integer, Integer>();
        for (Problem p : problem) {
            if (prev != p.problem) {
                prev = p.problem;
                notAc = true;
            }
            if (notAc && p.ans == 0) {
                waMemo.put(p.problem, waMemo.getOrDefault(p.problem, 0) + 1);
            } else if (p.ans == 1) {
                notAc = false;
                ac.add(p.problem);
            }
        }

        int wa = 0;
        for (int a : ac) {
            wa += waMemo.getOrDefault(a, 0);
        }
        out.println(ac.size() + " " + wa);
    }

    private static class Field {
        int h;
        int w;
        int num;

        public Field(int h, int w, int num) {
            this.h = h;
            this.w = w;
            this.num = num;
        }
    }

    private void solveD() {
        int h = nextInt();
        int w = nextInt();
        char[][] map = Stream.generate(() -> next().toCharArray()).limit(h).toArray(char[][]::new);

        int max = 0;
        int[] mH = new int[]{1, -1, 0, 0};
        int[] mW = new int[]{0, 0, 1, -1};
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                if (map[i][j] == '#')
                    continue;
                boolean[][] visited = new boolean[h][w];
                visited[i][j] = true;
                Field start = new Field(i, j, 0);
                Queue<Field> queue = new ArrayDeque<Field>();
                queue.add(start);
                while (queue.size() > 0) {
                    int count = queue.size();
                    for (int k = 0; k < count; k++) {
                        Field wk = queue.poll();
                        int wkCount = wk.num + 1;
                        for (int l = 0; l < 4; l++) {
                            int wkH = mH[l] + wk.h;
                            int wkW = mW[l] + wk.w;

                            if (wkH < 0 || wkH >= h || wkW < 0 || wkW >= w)
                                continue;
                            if (visited[wkH][wkW])
                                continue;
                            visited[wkH][wkW] = true;

                            if (map[wkH][wkW] == '#')
                                continue;
                            queue.add(new Field(wkH, wkW, wkCount));
                            max = Math.max(max, wkCount);
                        }
                    }
                }
            }
        }

        out.println(max);
    }

    private void solveE() {
        Scanner sc = new Scanner(System.in);

        // 入力
        final int CONST_MOD = (int) (Math.pow(10, 9) + 7);
        int n = nextInt();
        int k = nextInt();
        long[] wk = LongStream.range(0, n).map(i -> nextLong()).toArray();

        Arrays.sort(wk);

        // 計算
        long res = 0;
        long result;
        long maxSum = 0;
        long minSum = 0;
//        Combination combination = new Combination(n);
        for (int i = 0; i < n; i++) {
//            maxSum += wk[i] * combination.combination(i, k - 1) % CONST_MOD;
//            maxSum += wk[i] * combination (i + 1, k - 1, CONST_MOD) % CONST_MOD;
//            maxSum += wk[i] * combination.combination(i, k - 1) % CONST_MOD;
//            out.println("i:" + i + "/" + combination.combination(i, k - 1) + "/n-i-1:" + (n - i - 1) + "/" + combination.combination(n - i - 1, k - 1));
//            minSum += wk[i] * combination.combination(n - (i + 1), k - 1) % CONST_MOD;
//            minSum += wk[i] * combination(n - i - 1, k - 1, CONST_MOD) % CONST_MOD;
//            minSum += wk[i] * combination.combination(n - (i + 1), k - 1) % CONST_MOD;

            /*
            iはindexなので-1済み
             */
            long maxTotal = wk[i] * comb(i, k - 1, CONST_MOD) % CONST_MOD;
            res += maxTotal;
            res %= CONST_MOD;
            long minTotal = wk[i] * comb(n - i - 1, k - 1, CONST_MOD) % CONST_MOD;
            res -= minTotal;
            res %= CONST_MOD;
        }
//        result = maxSum + CONST_MOD - minSum;
//        result %= CONST_MOD;

        out.println(res);
//        out.println(result);


//        long maxSum = 0;
//        long minSum = 0;
//        Combination combination = new Combination(n);
//        for (int i = 0; i < n; i++) {

//        }
//        result = maxSum + CONST_MOD - minSum;
//        result %= CONST_MOD;
//        out.println(result);
//
    }

    private void solveF() {
        int n = nextInt();

        out.println("");
    }


    long[] fact;
    long[] factr;
    long[] inv;
    boolean initShortCombination = false;

    private long comb(int N_, int C_, int mo) {
        if (!initShortCombination) {
            int NUM_ = 400001;
            fact = new long[NUM_ + 1];
            factr = new long[NUM_ + 1];
            inv = new long[NUM_ + 1];
            initShortCombination = true;

            inv[1] = fact[0] = factr[0] = 1;
            for (int i = 2; i <= NUM_; ++i) {
                inv[i] = inv[mo % i] * (mo - mo / i) % mo;
            }
            for (int i = 1; i <= NUM_; ++i) {
                fact[i] = fact[i - 1] * i % mo;
                factr[i] = factr[i - 1] * inv[i] % mo;
            }
        }
        if (C_ < 0 || C_ > N_) return 0;
        return factr[C_] * fact[N_] % mo * factr[N_ - C_] % mo;
    }

    /*
     * 階乗計算の最大値
     * もっと大きいのが必要ならここを修正
     */
    private int FACTORIAL_NUM = 111111;
    /*
     * 階乗の事前計算（mod 済）
     */
    private long[] factorial = new long[FACTORIAL_NUM];
    /*
     * 逆数の事前計算（mod 済）
     */
    private long[] reverseFactorial = new long[FACTORIAL_NUM];
    private boolean isInitFactorial = false;

    /**
     * 階乗計算の事前累積和
     * [1, 1, 2, 3, 4, 5, … FACTORIAL_NUM]
     * mod済
     */
    private void initFactorial(long mod) {
        factorial[0] = 1;
        for (int i = 1; i < FACTORIAL_NUM; i++) {
            factorial[i] = (factorial[i - 1] * i) % mod;
        }
    }

    /**
     * 逆数の事前計算
     * もっと速い方法があったので修正
     */
    private void initReverseFactorial(long mod) {

//        reverseFactorial[FACTORIAL_NUM - 1] = modInverse(factorial[FACTORIAL_NUM - 1], mod);
//        for (int i = FACTORIAL_NUM - 2; i >= 0; i--) {
//            /*
//             * 以下を利用する。
//             * これにより毎回modInverseしなくてよくなる
//             * (N!)^(-1) * N -> ((N - 1)!)^(-1)
//             * (N-1!)^(-1) * N -> ((N - 2)!)^(-1)
//             */
//            reverseFactorial[i] = (reverseFactorial[i + 1] * (i + 1)) % mod;
//        }
        reverseFactorial[0] = 1;
        for (int i = 0; i < FACTORIAL_NUM; i++) {
            reverseFactorial[i] = modInverse(factorial[i], mod);
        }
    }

    /**
     * フェルマーの小定理を用いて逆元を求める。
     * ある数xのmod p（pは素数）の逆数x'はx' = x^(p-2)
     * 繰り返し二乗法を用いて計算する。
     * http://satanic0258.hatenablog.com/entry/2016/04/29/004730
     * {@link BigInteger#modInverse(BigInteger)}とどちらが速いか？
     *
     * @param x
     * @return
     */
    private long modInverse(long x, long mod) {
        long res = 1L;
        long k = mod - 2L;
        long y = x;
        while (k != 0) {
            if (k % 2 != 0) {
                res = (res * y) % mod;
            }
            y = (y * y) % mod;
            k /= 2;
        }
        return res;
    }

    private void initFactorialCalc(long mod) {
        if (isInitFactorial) {
            //初期化済みならreturn
            return;
        }
        //階乗の事前計算
        initFactorial(mod);
        //逆数の計算もしておく
        initReverseFactorial(mod);
        isInitFactorial = true;
    }

    /**
     * 組み合わせ
     * nCk -> n! / k!・(n-k)!
     *
     * @param n
     * @param k
     * @param mod
     * @return
     */
    private long combination(int n, int k, long mod) {
        initFactorialCalc(mod);
        if (k < 0 || n < k) {
            return 0;
        }

        //分子の計算
        long calResN = factorial[n];

        //分母の計算
        long calResNK = reverseFactorial[n - k];
        long calcResK = reverseFactorial[k];
        long denominator = (calResNK * calcResK) % mod;

        return (calResN * denominator) % mod;

    }

    /**
     * 順列
     * nPk -> n! / (n-k)!
     *
     * @param n
     * @param k
     * @return
     */
    private long permutation(int n, int k, long mod) {
        initFactorialCalc(mod);
        if (k < 0 || n < k) {
            return 0;
        }
        long calResN = factorial[n];
        long calResNK = reverseFactorial[n - k];
        return (calResN * calResNK) % mod;
    }

    /**
     * 多項係数
     * 文字aをp個,bをq個,cをr個, dをs個 あわせてn個を1列に並べるときの並べ方
     * n! / p!・q!・r!・s!
     *
     * @param n
     * @param strNum
     * @param mod
     * @return
     */
    private long multinominalCoefficient(int n, List<Integer> strNum, int mod) {
        initFactorialCalc(mod);

        long calResN = factorial[n];
        long calResDenomi = 1;
        for (Integer num : strNum) {
            calResDenomi *= reverseFactorial[num];
        }
        return (calResN * calResDenomi) % mod;
    }

    /**
     * 重複組合せ nHr （同次積）
     * nHr = (n+r-1)Cr
     * 異なるn個のものから重複を許してr個取る組合せの総数
     * 例：
     * リンゴ，ミカン，牛肉の3種類の果物があります．これらの中から6個の食材を買って帰ります．
     * このとき，何通りの買い方がありますか？ただし，含まれない食材があってもよいものとします
     *
     * @param n
     * @param r
     * @param mod
     * @return
     */
    private long homogeneousProduct(int n, int r, long mod) {
        if (n == 0 && r == 0) {
            return 1;
        }
        return combination(n + r - 1, r, mod);
    }

    private final PrintWriter out = new PrintWriter(System.out);
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
    }

    public boolean hasNext() {
        skipUnprintable();
        return hasNextByte();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
}

class Combination {
    static final int MOD = (int) (Math.pow(10, 9) + 7);
    long[] fact;
    long[] invFact;
    long[] inv;

    public Combination(int n) {
        fact = new long[n + 1];
        invFact = new long[n + 1];
        inv = new long[n + 1];
        fact[0] = 1;
        fact[1] = 1;
        invFact[0] = 1;
        invFact[1] = 1;
        inv[1] = 1;
        for (int i = 2; i < n + 1; i++) {
            fact[i] = fact[i - 1] * i % MOD;
            inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
            invFact[i] = invFact[i - 1] * inv[i] % MOD;
        }
    }

    public long combination(int n, int k) {
        if (n < k || n < 0 || k < 0) {
            return 0;
        }
        return fact[n] * (invFact[k] * invFact[n - k] % MOD) % MOD;
    }
}

Measured memory_bytes: 37884