unittest
{
	assert( [ "4 2", "1 1 3 4" ].parse.expand.solve == 11 );
	assert( [ "6 3", "10 10 10 -10 -10 -10" ].parse.expand.solve == 360 );
	assert( [ "3 1", "1 1 1" ].parse.expand.solve == 0 );
	assert( [ "10 6", "1000000000 1000000000 1000000000 1000000000 1000000000 0 0 0 0 0" ].parse.expand.solve == 999998537 );
}



import std.algorithm;
import std.conv;
import std.range;
import std.stdio;
import std.typecons;

void main()
{
	stdin.byLineCopy.parse.expand.solve.writeln;
}

auto parse( Range )( Range input )
if( isInputRange!Range && is( ElementType!Range == string ) )
{
	auto nk = input.front.split.to!( long[] );
	input.popFront;
	auto as = input.front.split.to!( long[] );
	return tuple( nk[ 1 ], as );
}

auto solve( long k, long[] as )
{
	if( k == 1 ) return 0;
	
	as.sort();
	
	// マイナス値をmodの世界に合わせる
	foreach( ref a; as )
	{
		a = a.normalizeMod;
	}
	
	// 累積和表を作成
	auto ts = new long[ 1 + as.length ];
	foreach( i; 0L .. as.length.signed )
	{
		ts[ i + 1 ] = ts[ i ].addMod( as[ i ] );
	}
	
	// 任意の連続するw個の範囲からk個を選択したときの合計を計算
	auto ans = 0L;
	foreach( w; k .. as.length.signed + 1 )
	{
		auto ma = ts[ $ - 1 ].subMod( ts[ w - 1 ] );
		auto mi = ts[ $ - w ];
		auto f = ma.subMod( mi );
		auto c = ( w - 2 ).combinationMod( k - 2 );
		ans = ans.addMod( f.mulMod( c ) );
	}
	return ans;
}

// マイナス値を補正
auto normalizeMod( long MOD = 10L ^^ 9 + 7 )( long x )
{
	return ( 0 <= x ) ? ( x % MOD ) : ( MOD + x );
}

// 足し算
auto addMod( long MOD = 10L ^^ 9 + 7 )( long x, long y )
{
	return ( x + y ) % MOD;
}

// 引き算
auto subMod( long MOD = 10L ^^ 9 + 7 )( long x, long y )
{
	return ( x + MOD - y ) % MOD;
}

// 掛け算
auto mulMod( long MOD = 10L ^^ 9 + 7 )( long x, long y )
{
	return x * y % MOD;
}

// 割り算
auto divMod( long MOD = 10L ^^ 9 + 7 )( long x, long y )
{
	return x * y.powMod!MOD( MOD - 2 ) % MOD;
}

// べき乗
auto powMod( long MOD = 10L ^^ 9 + 7 )( long x, long y )
{
	auto a = 1L;
	for( ; 0 < y; y >>= 1 )
	{
		if( y & 1 ) a = a * x % MOD;
		x = x ^^ 2 % MOD;
	}
	return a;
}

// 階乗
auto factorialMod( long MOD = 10L ^^ 9 + 7 )( long x )
{
	static memo = [ 1L ];
	if( memo.length <= x )
	{
		auto i = memo.length;
		memo.length = x + 1;
		for( ; i <= x; i++ ) memo[ i ] = memo[ i - 1 ] * i % MOD;
	}
	return memo[ x ];
}

// 組み合わせ数
auto combinationMod( long MOD = 10L ^^ 9 + 7 )( long x, long y )
{
	return x.factorialMod!MOD.divMod!MOD( y.factorialMod!MOD.mulMod!MOD( ( x - y ).factorialMod!MOD ) );
}
