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.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.concurrent.ThreadLocalRandom;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ijxjdjd
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        BeautifulArray solver = new BeautifulArray();
        solver.solve(1, in, out);
        out.close();
    }

    static class BeautifulArray {
        long MOD = 998244353;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            int K = in.nextInt();
            int[] arr = new int[N + 1];
            for (int i = 1; i <= N; i++) {
                int a = in.nextInt();
                arr[i] = a;
            }
            arr[0] = -10000000;
            ArrayUtils.sort(arr);
            long[] less = new long[100000 / (K - 1) + 1];
            int[] low = new int[N + 1];
            for (int i = 100000 / (K - 1); i >= 0; i--) {
                for (int id = 1; id <= N; id++) {
                    while (low[id] < id && arr[id] - arr[low[id]] >= i) {
                        low[id]++;
                    }
                }
                long[][] dp = new long[K + 1][N + 1];
                Arrays.fill(dp[1], 1);
                dp[1][0] = 0;
                for (int v = 1; v <= N; v++) {
                    dp[1][v] += dp[1][v - 1];
                }
                for (int k = 2; k <= K; k++) {
                    for (int v = 1; v <= N; v++) {
                        dp[k][v] += dp[k - 1][low[v] - 1];
                        dp[k][v] += dp[k][v - 1];
                        dp[k][v] %= MOD;
                    }
                }
                less[i] = dp[K][N] - dp[K][0];
            }
            long ans = 0;
            ans += less[100000 / (K - 1)] * (100000) / (K - 1);
            for (int i = 0; i < (100000) / (K - 1); i++) {
                ans += (less[i] - less[i + 1]) * i;
                ans %= MOD;
            }
            out.println(ans);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }

    static class ArrayUtils {
        public static void shuffle(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                int rand = (int) MathUtils.mod(ThreadLocalRandom.current().nextInt(), (i + 1));
                swap(arr, i, rand);
            }
        }

        public static void swap(int[] arr, int i, int j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        public static void sort(int[] arr) {
            shuffle(arr);
            Arrays.sort(arr);
            //get rid of quicksort cases
        }

    }

    static class MathUtils {
        public static long mod(long a, long mod) {
            return (a + (Math.abs(a) + mod - 1) / mod * mod) % mod;
        }

    }
}

