Let's call beauty of an array b_1, b_2, …, b_n (n > 1) — min_{1 ≤ i < j ≤ n} |b_i - b_j|.

You're given an array a_1, a_2, … a_n and a number k. Calculate the sum of beauty over all subsequences of the array of length exactly k. As this number can be very large, output it modulo 998244353.

A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements.

Input

The first line contains integers n, k (2 ≤ k ≤ n ≤ 1000).

The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^5).

Output

Output one integer — the sum of beauty over all subsequences of the array of length exactly k. As this number can be very large, output it modulo 998244353.

Examples

Input


4 3
1 7 3 5


Output


8

Input


5 5
1 10 100 1000 10000


Output


9

Note

In the first example, there are 4 subsequences of length 3 — [1, 7, 3], [1, 3, 5], [7, 3, 5], [1, 7, 5], each of which has beauty 2, so answer is 8.

In the second example, there is only one subsequence of length 5 — the whole array, which has the beauty equal to |10-1| = 9.
/*
 ID: tommatt1
 LANG: JAVA
 TASK: 
*/
//
import java.util.*;
import java.io.*;
public class cf1189f{

	public static void main(String[] args)throws IOException {
		PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer(bf.readLine());
		int n=Integer.parseInt(st.nextToken());
		int k=Integer.parseInt(st.nextToken());
		int mod=998244353;
		long[][] dp=new long[n+1][k+1];
		long ans=0;
		int[] a1=new int[n];
		st=new StringTokenizer(bf.readLine());
		for(int i=0;i<n;i++) {
			a1[i]=Integer.parseInt(st.nextToken());
		}
		sort(a1);
		int[] a=new int[n+1];
		for(int i=0;i<n;i++) {
			a[i+1]=a1[i];
		}
		for(int x=1;x*(k-1)<=a[n]-a[1];x++) {
			int idx=1;
			dp[0][0]=1;
			for(int i=1;i<=n;i++) {
				dp[i][0]=1;
				while(a[idx]<=a[i]-x) {
					idx++;
				}
				for(int j=1;j<=k;j++) {
					dp[i][j]=(dp[i-1][j]+dp[idx-1][j-1])%mod;
				}
			}
			ans=(ans+dp[n][k])%mod;
		}
		out.println(ans);
		out.close();
	}
	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

}
