/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author aryssoncf
 */



// Taken from: https://github.com/bqi343/USACO/blob/master/Implementations/content/contest/templateShort.cpp

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<ull> vul;
typedef vector<ll> vl;
typedef vector<pi> vpi;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i,0,a)
#define ROF(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i, a) ROF(i,0,a)
#define trav(a, x) for (auto& a: x)

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize

#define mp make_pair
#define pb push_back
#define f first
#define s second

const int MOD = 1e9 + 7; // 998244353; // = (119<<23)+1
const int MX = 2e5 + 5;

template<class T>
bool ckmin(T &a, const T &b) {
    return a > b ? a = b, 1 : 0;
}

template<class T>
bool ckmax(T &a, const T &b) {
    return a < b ? a = b, 1 : 0;
}

mt19937 rng((uint32_t) chrono::steady_clock::now().time_since_epoch().count());


//
// Created by aryssoncf on 28/10/2019.
//

#include <type_traits>


#include <iterator>
#include <utility>

template<typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
    return true;
}

constexpr bool hasBegin(...) {
    return false;
}

template<typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;


#ifndef JHELPER_EXAMPLE_PROJECT_IO_HPP
#define JHELPER_EXAMPLE_PROJECT_IO_HPP

#endif //JHELPER_EXAMPLE_PROJECT_IO_HPP

template<typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
    for (T &element: vec) {
        is >> element;
    }
    return is;
}

template<typename T, typename U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
    is >> p.first;
    is >> p.second;
    return is;
}

template<class X, class Y>
std::ostream &operator<<(std::ostream &os, std::pair<X, Y> const &p) {
    return os << p.first << " " << p.second;
}

template<class Ch, class Tr, class Container>
std::basic_ostream<Ch, Tr> &operator<<(std::basic_ostream<Ch, Tr> &os, Container const &x) {
    bool first = true;
    for (auto &y : x) {
        if (first) {
            first = false;
        } else {
            os << " ";
        }
        os << y;
    }
    return os;
}


#include <iostream>
#include <assert.h>


#include <string>
#include <stdexcept>

#ifndef SPCPPL_ASSERT
#ifdef SPCPPL_DEBUG
#define SPCPPL_ASSERT(condition) \
        if(!(condition)) { \
            throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
        }
#else
#define SPCPPL_ASSERT(condition)
#endif
#endif


template<typename T, typename = std::true_type>
struct IdentityHelper;

template<typename T>
struct IdentityHelper<T, typename std::is_arithmetic<T>::type> {
    static T identity() {
        return 1;
    }
};

template<typename T>
T identity() {
    return IdentityHelper<T>::identity();
}


/**
* ax + by = result
*/
template<typename T>
T extendedGcd(T a, T b, T &x, T &y) {
    if (a == 0) {
        x = 0;
        y = 1;
        return b;
    }
    T d = extendedGcd(b % a, a, y, x);
    x -= (b / a) * y;
    return d;
}

template<typename T>
class Zn {
public:
    Zn() : value(0) {
    }

    Zn(int64_t value) : value(value) {
        int x = static_cast<int>(value % mod());
        if (x < 0) {
            x += mod();
        }
        this->value = x;
    }

    template<typename U>
    static Zn valueOf(U value) {
        int x = static_cast<int>(value % mod());
        if (x < 0) {
            x += mod();
        }
        return Zn(x);
    }

    static Zn rawValueOf(int value) {
        SPCPPL_ASSERT(value >= 0 && value < mod());
        return Zn(value);
    }

    template<typename U>
    Zn &operator=(U rhs) {
        return *this = Zn::valueOf(rhs);
    }


    Zn &operator+=(const Zn &rhs) {
        value += rhs.value;
        if (value >= mod()) {
            value -= mod();
        }
        return *this;
    }

    template<typename U>
    Zn &operator+=(U rhs) {
        return *this += Zn::valueOf(rhs);
    }

    Zn &operator-=(const Zn &rhs) {
        value -= rhs.value;
        if (value < 0) {
            value += mod();
        }
        return *this;
    }

    template<typename U>
    Zn &operator-=(U rhs) {
        return *this -= Zn::valueOf(rhs);
    }

    Zn &operator*=(const Zn &rhs) {
        long long result = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
        value = static_cast<int>(result % mod());
        return *this;
    }

    template<typename U>
    Zn &operator*=(U rhs) {
        return *this *= Zn::valueOf(rhs);
    }

    Zn operator-() const {
        if (value == 0) {
            return *this;
        } else {
            return Zn(mod() - value);
        }
    }

    Zn &operator/=(const Zn &rhs) {
        return *this *= rhs.inversed();
    }

    template<typename U>
    Zn &operator/=(U rhs) {
        return *this /= Zn::valueOf(rhs);
    }

    Zn inv() const {
        return inversed();
    }

    inline Zn inversed() const {
        SPCPPL_ASSERT(value != 0);

        int x, y;
        int gcd = extendedGcd(value, mod(), x, y);
        (void) gcd;
        SPCPPL_ASSERT(gcd == 1);

        if (x < 0) {
            x += mod();
        }
        return Zn(x);
    }

    template<typename U>
    friend std::ostream &operator<<(std::ostream &, const Zn<U> &zn);

    template<typename U>
    friend std::istream &operator>>(std::istream &, Zn<U> &zn);

    template<typename U>
    friend bool operator==(const Zn<U> &lhs, const Zn<U> &rhs);

    int intValue() const {
        return value;
    }

    operator int64_t() const {
        return value;
    }

    constexpr static int mod() {
        return T::value;
    }

private:
    int value;

    template<int N = T::value>
    static constexpr bool correct_or_runtime(int) {
        return N > 0 && N <= (1 << 30);
    }

    static constexpr bool correct_or_runtime(...) {
        return true;
    }

    static_assert(
            std::is_same<typename std::decay<decltype(T::value)>::type, int>::value,
            "T::value must be int"
    );
    static_assert(correct_or_runtime(0), "Mod has to be positive integer up to 1 << 30");
};

template<typename T>
bool operator==(const Zn<T> &lhs, const Zn<T> &rhs) {
    return lhs.value == rhs.value;
}

template<typename T, typename U>
bool operator==(const Zn<T> &lhs, U rhs) {
    return lhs == Zn<T>::valueOf(rhs);
}

template<typename T, typename U>
bool operator==(U lhs, const Zn<T> &rhs) {
    return rhs == lhs;
}

template<typename T>
bool operator!=(const Zn<T> &lhs, const Zn<T> &rhs) {
    return !(lhs == rhs);
}

template<typename T, typename U>
bool operator!=(const Zn<T> &lhs, U rhs) {
    return !(lhs == rhs);
}

template<typename T, typename U>
bool operator!=(U lhs, const Zn<T> &rhs) {
    return !(lhs == rhs);
}

template<typename T>
Zn<T> operator+(const Zn<T> &lhs, const Zn<T> &rhs) {
    Zn<T> copy = lhs;
    return copy += rhs;
}

template<typename T, typename U>
Zn<T> operator+(const Zn<T> &lhs, U rhs) {
    Zn<T> copy = lhs;
    return copy += rhs;
}

template<typename T, typename U>
Zn<T> operator+(U lhs, const Zn<T> &rhs) {
    return rhs + lhs;
}

template<typename T>
Zn<T> operator-(const Zn<T> &lhs, const Zn<T> &rhs) {
    Zn<T> copy = lhs;
    return copy -= rhs;
}

template<typename T, typename U>
Zn<T> operator-(const Zn<T> &lhs, U rhs) {
    Zn<T> copy = lhs;
    return copy -= rhs;
}

template<typename T, typename U>
Zn<T> operator-(U lhs, const Zn<T> &rhs) {
    return Zn<T>::valueOf(lhs) - rhs;
}

template<typename T>
Zn<T> operator*(const Zn<T> &lhs, const Zn<T> &rhs) {
    Zn<T> copy = lhs;
    return copy *= rhs;
}

template<typename T, typename U>
Zn<T> operator*(const Zn<T> &lhs, U rhs) {
    Zn<T> copy = lhs;
    return copy *= rhs;
}

template<typename T, typename U>
Zn<T> operator*(U lhs, const Zn<T> &rhs) {
    return rhs * lhs;
}

template<typename T>
Zn<T> operator/(const Zn<T> &lhs, const Zn<T> &rhs) {
    Zn<T> copy = lhs;
    return copy /= rhs;
}

template<typename T, typename U>
Zn<T> operator/(const Zn<T> &lhs, U rhs) {
    Zn<T> copy = lhs;
    return copy /= rhs;
}

template<typename T, typename U>
Zn<T> operator/(U lhs, const Zn<T> &rhs) {
    return Zn<T>::valueOf(lhs) / rhs;
}

template<typename T>
std::ostream &operator<<(std::ostream &stream, const Zn<T> &zn) {
    return stream << zn.value;
}

template<typename T>
std::istream &operator>>(std::istream &stream, Zn<T> &zn) {
    int64_t value;
    stream >> value;
    zn.value = static_cast<int>(value % T::value);
    return stream;
}

template<typename T>
struct IdentityHelper<Zn<T>> {
    static Zn<T> identity() {
        return Zn<T>::valueOf(1);
    }
};

template<int m>
using ZnConst = Zn<std::integral_constant<int, m>>;

using Zn7 = ZnConst<1000000007>;


#include <vector>
#include <cstddef>
#include <cstdint>


template<typename T>
T factorial(std::size_t maxN) {
    T result = identity<T>();
    for (std::size_t i = 2; i <= maxN; ++i) {
        result *= static_cast<int64_t>(i);
    }
    return result;
}

template<typename T>
std::vector<T> factorials(std::size_t maxN) {
    std::vector<T> res(maxN + 1);
    res[0] = identity<T>();
    for (std::size_t i = 1; i <= maxN; ++i) {
        res[i] = res[i - 1] * static_cast<long long>(i);
    }
    return res;
}

template<typename T>
std::vector<std::vector<T>> binomials(std::size_t maxN) {
    std::vector<std::vector<T>> res(maxN + 1, std::vector<T>(maxN + 1));
    for (std::size_t n = 0; n <= maxN; ++n) {
        res[n][0] = identity<T>();
        res[n][n] = identity<T>();
        for (std::size_t k = 1; k < n; ++k) {
            res[n][k] = res[n - 1][k - 1] + res[n - 1][k];
        }
    }

    return res;
}

template<typename T, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
T binomial(U n, U k) {
    if (k > n || k < 0) {
        return T();
    }
    T res = identity<T>();
    for (U i = 1; i <= k; ++i) {
        res *= n - i + 1;
        res /= i;
    }
    return res;
};

template<typename T, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
std::vector<T> pascalTriangleRow(U n, U k) {
    SPCPPL_ASSERT(k >= 0);
    std::vector<T> result(k + 1);
    result[0] = identity<T>();
    for (U i = 1; i <= k; ++i) {
        result[i] = result[i - 1] * (n - i + 1) / i;
    }
    return result;
};

template<typename T, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
std::vector<T> pascalTriangleRow(U n) {
    return pascalTriangleRow<T>(n, n);
};

template<typename T, typename U, typename = std::enable_if_t<std::is_integral<U>::value>>
T starsAndBars(U stars, U groups) {
    if (groups == 0) {
        if (stars == 0) {
            return identity<T>();
        } else {
            return T();
        }
    }
    return binomial<T>(stars + groups - 1, groups - 1);
};


using namespace std;

/*
PROG:
LANG: C++
*/

class EMaxMinSums {
    using Z = Zn7;

public:
    void solve(std::istream &in, std::ostream &out) {
        int n, k;
        in >> n >> k;
        vi A(n);
        in >> A;
        sort(all(A));
        Z res = 0;
        vector<Z> facs = factorials<Z>(n);

        auto C = [&](int n, int p) {
            return p > n ? (Z) 0 : facs[n] / facs[p] / facs[n - p];
        };

        FOR(i, 0, n) {
            res += C(i, k - 1) * A[i];
        }
        FOR(i, 0, n) {
            res -= C(n - 1 - i, k - 1) * A[i];
        }
        out << res << "\n";
    }

    void setup() {}
};


int main() {
    std::ios_base::sync_with_stdio(false);
    EMaxMinSums solver;
    solver.setup();
    std::istream &in(std::cin);
    std::ostream &out(std::cout);
    in.tie(nullptr);
    out << std::fixed;
    out.precision(20);
    solver.solve(in, out);
    return 0;
}


Measured memory_bytes: 1024