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.
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
T pow(T a, ll b) {
  T r = 1;
  for (; b; b /= 2, a *= a)
    if (b % 2) r *= a;
  return r;
}
template <int MOD>
struct modint {
 private:
  int v;

 public:
  modint() : v(0) {}
  modint(ll x) : v(x % MOD) {
    if (v < 0) v += MOD;
  }
  explicit operator int() const { return v; }
  friend ostream &operator<<(ostream &out, const modint &a) {
    return out << int(a);
  }
  friend istream &operator>>(istream &in, modint &a) {
    ll x;
    in >> x;
    a = modint(x);
    return in;
  }
  friend bool operator==(const modint &a, const modint &b) {
    return a.v == b.v;
  }
  friend bool operator!=(const modint &a, const modint &b) {
    return a.v != b.v;
  }
  modint inv() const {
    modint r = v;
    r = pow(r, MOD - 2);
    return r;
  }
  friend modint inv(const modint &x) { return x.inv(); }
  modint neg() const { return modint(v ? MOD - v : 0); }
  friend modint neg(const modint &x) { return x.neg(); }
  modint operator-() const { return neg(); }
  modint operator+() const { return mogint(*this); }
  modint &operator++() {
    v++;
    if (v == MOD) v = 0;
    return *this;
  }
  modint &operator--() {
    v--;
    if (v < 0) v += MOD;
    return *this;
  }
  modint &operator+=(const modint &a) {
    v += a.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  modint &operator-=(const modint &a) {
    v -= a.v;
    if (v < 0) v += MOD;
    return *this;
  }
  modint &operator*=(const modint &a) {
    v = ll(v) * ll(a.v) % MOD;
    return *this;
  }
  modint &operator/=(const modint &a) { return *this *= a.inv(); }
  friend modint operator++(const modint &a, int) {
    modint r = a;
    ++a;
    return r;
  }
  friend modint operator--(const modint &a, int) {
    modint r = a;
    --a;
    return r;
  }
  friend modint operator+(const modint &a, const modint &b) {
    return modint(a) += b;
  }
  friend modint operator-(const modint &a, const modint &b) {
    return modint(a) -= b;
  }
  friend modint operator*(const modint &a, const modint &b) {
    return modint(a) *= b;
  }
  friend modint operator/(const modint &a, const modint &b) {
    return modint(a) /= b;
  }
};
using mint = modint<998244353>;
int n, k;
vector<int> v;
vector<vector<mint>> dp;
vector<mint> base;
mint solve(int x) {
  int it = -1;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j <= k; ++j) {
      dp[i][j] = i > 0 ? dp[i - 1][j] : base[j];
    }
    while (it + 1 < i && v[it + 1] + x <= v[i]) ++it;
    for (int j = 0; j < k; ++j) {
      dp[i][j + 1] += it >= 0 ? dp[it][j] : base[j];
    }
  }
  return dp[n - 1][k];
}
int main() {
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cin >> n >> k;
  v.resize(n);
  dp.assign(n, vector<mint>(k + 1));
  base.resize(k + 1);
  base[0] = 1;
  for (int i = 0; i < n; ++i) cin >> v[i];
  sort(v.begin(), v.end());
  mint r;
  for (int i = 1; i * (k - 1) <= v.back(); ++i) r += solve(i);
  cout << r << '\n';
}
