Once upon a time, Oolimry saw a suffix array. He wondered how many strings can produce this suffix array. 

More formally, given a suffix array of length n and having an alphabet size k, count the number of strings that produce such a suffix array. 

Let s be a string of length n. Then the i-th suffix of s is the substring s[i … n-1]. A suffix array is the array of integers that represent the starting indexes of all the suffixes of a given string, after the suffixes are sorted in the lexicographic order. For example, the suffix array of oolimry is [3,2,4,1,0,5,6] as the array of sorted suffixes is [imry,limry,mry,olimry,oolimry,ry,y]. 

A string x is lexicographically smaller than string y, if either x is a prefix of y (and x≠ y), or there exists such i that x_i < y_i, and for any 1≤ j < i , x_j = y_j.

Input

The first line contain 2 integers n and k (1 ≤ n ≤ 200000,1 ≤ k ≤ 200000) — the length of the suffix array and the alphabet size respectively.

The second line contains n integers s_0, s_1, s_2, …, s_{n-1} (0 ≤ s_i ≤ n-1) where s_i is the i-th element of the suffix array i.e. the starting position of the i-th lexicographically smallest suffix. It is guaranteed that for all 0 ≤ i< j ≤ n-1, s_i ≠ s_j.

Output

Print how many strings produce such a suffix array. Since the number can be very large, print the answer modulo 998244353.

Examples

Input


3 2
0 2 1


Output


1

Input


5 1
0 1 2 3 4


Output


0

Input


6 200000
0 1 2 3 4 5


Output


822243495

Input


7 6
3 2 4 1 0 5 6


Output


36

Note

In the first test case, "abb" is the only possible solution. 

In the second test case, it can be easily shown no possible strings exist as all the letters have to be equal. 

In the fourth test case, one possible string is "ddbacef".

Please remember to print your answers modulo 998244353.
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <ctime>
#include <chrono>
#include <random>
#include <bitset>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <algorithm>
#include <unordered_map>

#define fi first
#define se second
#define il inline
#define Ld double
#define pc putchar
#define rg register
#define ll long long
#define lll __int128
#define pb push_back
#define mp make_pair
#define It ::iterator
#define W(p) while(p--)
#define pll pair<ll, ll>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pii pair<int, int>
#define ull unsigned long long
#define all(x) x.begin(), x.end()
#define def(N, K, b) const K N = b;
#define FOR(i, b, s) for(int i = (b); i < (s); ++i) 
#define rep(i, b, s) for(int i = (b); i <= (s); ++i)
#define per(i, b, s) for(int i = (b); i >= (s); --i)
#define FOR_(i, b, s) for(int i = (b); i > (s); --i) 
#define ios ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

namespace IO {
    const int SIZE = (1 << 20) + 1;
    char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = obuf + SIZE - 1;
    char _st[55];
    int _qr = 0;
    inline char gc() {
        return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS++) : *iS++);
    }
    inline void qread() {}
    template<class T1, class ...T2>
    inline void qread(T1 &IEE, T2&... ls) {
        register T1 __ = 0, ___ = 1;
        register char ch;
        while(!isdigit(ch = gc())) ___ = (ch == '-') ? -___ : ___;
        do {
            __ = (__ << 1) + (__ << 3) + (ch ^ 48);
        }while(isdigit(ch = gc()));
        __ *= ___;
        IEE = __;
        qread(ls...);
        return ;
    }
    template<class T>
	inline void QreadArr(T Begin, T End) {
		while(Begin != End) {
			qread(*Begin);
			++Begin;
		}
	}
    inline void flush() {
        fwrite(obuf, 1, oS - obuf, stdout);
        oS = obuf;
        return ;
    }
    inline void putc_(char _x) {
        *oS++ = _x;
        if(oS == oT) flush();
    }
    inline void qwrite() {}
    template<class T1, class ...T2>
    inline void qwrite(T1 IEE, T2... ls) {
        if(!IEE) putc_('0');
        if(IEE < 0) putc_('-'), IEE = -IEE;
        while(IEE) _st[++_qr] = IEE % 10 + '0', IEE /= 10;
        while(_qr) putc_(_st[_qr--]);
        qwrite(ls...);
        return ;
    }
    template<class T>
    inline void WriteArr(T Begin, T End) {
    	const char Kg = ' ', Edl = '\n';
    	while(Begin != End) {
    		qwrite(*Begin);
    		++Begin;
    		putc_(Kg);
		}
		putc_(Edl);
	}
    struct Flusher_{ ~Flusher_() { flush(); } } io_flusher;
}

using namespace IO;
using namespace std;

mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
ll My_Rand(ll Mod) { return (ull)(rnd()) % Mod; }

template<class T1, class T2>
T1 Min(const T1 x, const T2 y) { return x > y ? y : x; }
template<class T1, class T2>
T1 Max(const T1 x, const T2 y) { return x > y ? x : y; }

template<class T1, class T2>
void To_max(T1 &x, const T2 y) { x < y ? x = y : x = x; }
template<class T1, class T2>
void To_min(T1 &x, const T2 y) { x > y ? x = y : x = x; }

il ll qmul(ll x, ll y, ll p) {
	ll l = x * (y >> 25) % p * (1 << 25) % p;
	ll r = x * (y & ((1 << 25) - 1)) % p;
	return (l + r) % p;	
}

il ll qpow(ll n, ll base, ll mod = 1e18) {
	ll ret = 1;
	while(n) {
		if(n & 1) ret = ret * base % mod;
		base = base * base % mod;
		n >>= 1;
	}
	return ret % mod;
}

il ll gcd(ll x, ll y) { return !y ? x : gcd(y, x % y); }
il ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }

void InitHash(ull &base, int &prime, ull &mod) { base = 131, prime = 233317, mod = 212370440130137957ll; } 
//header

def(N, int, 2e5 + 5)
def(p, int, 998244353)

int n, k, cnt;
int suf[N], rk[N];
ll inv[N << 1], fac[N << 1], Inv[N << 1];

void init() {
	inv[0] = fac[0] = Inv[0] = inv[1] = fac[1] = Inv[1] = 1;
	rep(i, 2, int(4e5)) {
		fac[i] = fac[i - 1] * i % p;
		inv[i] = p - (p / i) * inv[p % i] % p;
		Inv[i] = Inv[i - 1] * inv[i] % p;
	}
}

ll Ans(int n, int m) {
	if(m > n) return 0;
	return ((fac[n] * Inv[n - m]) % p) * Inv[m] % p;
}

int main() {
	init();
	qread(n, k);
	rep(i, 1, n) qread(suf[i]), ++suf[i];
	rep(i, 1, n) rk[suf[i]] = i;
	rep(i, 1, n - 1) {
		int x = suf[i], y = suf[i + 1];
		cnt += (rk[x + 1] > rk[y + 1]);
	}
	printf("%lld\n", Ans(n + k - cnt - 1, n));
 	return 0;
}
