#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 7;
const long long MOD = 998244353;
const long long PIERW = 100;
int ciag[MAX];
int ostatnie[MAX];
int poprzedni[MAX];
long long pomocnicza[MAX];
long long DP[MAX];
struct Blok {
  int lewa, prawa;
  long long suma;
  long long sumaDP[PIERW * 2 + 1];
  void Aktualizuj() {
    for (int i = 0; i <= 2 * PIERW; ++i) sumaDP[i] = 0;
    suma = 0;
    for (int i = prawa; i >= lewa; --i) {
      suma += pomocnicza[i];
      sumaDP[suma + PIERW] = (sumaDP[suma + PIERW] + DP[i - 1]) % MOD;
    }
    for (int i = 1; i <= 2 * PIERW; i++)
      sumaDP[i] = (sumaDP[i] + sumaDP[i - 1]) % MOD;
  }
};
Blok bloki[MAX / PIERW + 7];
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int n, k;
  cin >> n >> k;
  DP[0] = 1;
  for (int i = 0; i * PIERW <= n; ++i) {
    bloki[i].lewa = i * PIERW + 1;
    bloki[i].prawa = (i + 1) * PIERW;
    bloki[i].Aktualizuj();
  }
  for (int i = 1; i <= n; ++i) {
    cin >> ciag[i];
    poprzedni[i] = ostatnie[ciag[i]];
    ostatnie[ciag[i]] = i;
    pomocnicza[i] = 1;
    pomocnicza[poprzedni[i]] = -1;
    int t = poprzedni[poprzedni[i]];
    pomocnicza[t] = 0;
    bloki[(i - 1) / PIERW].Aktualizuj();
    bloki[(poprzedni[i] - 1) / PIERW].Aktualizuj();
    bloki[(t - 1) / PIERW].Aktualizuj();
    int blok = (i - 1) / PIERW;
    long long suma = 0;
    for (int j = blok; j >= 0; --j) {
      int x = min(k - suma, PIERW);
      if (-PIERW <= x && x <= PIERW)
        DP[i] = (DP[i] + bloki[j].sumaDP[x + PIERW]) % MOD;
      suma += bloki[j].suma;
    }
    bloki[i / PIERW].Aktualizuj();
  }
  cout << DP[n] << "\n";
  return 0;
}

### Prompt

Construct a CPP code solution to the problem outlined:

Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.

Since the answer can be large, find it modulo 998 244 353.

Input

The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of elements in the array a and the restriction from the statement.

The following line contains n space-separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — elements of the array a.

Output

The first and only line contains the number of ways to divide an array a modulo 998 244 353.

Examples

Input


3 1
1 1 2


Output


3


Input


5 2
1 1 2 1 3


Output


14


Input


5 5
1 2 3 4 5


Output


16

Note

In the first sample, the three possible divisions are as follows.

  * [[1], [1], [2]] 
  * [[1, 1], [2]] 
  * [[1, 1, 2]] 



Division [[1], [1, 2]] is not possible because two distinct integers appear exactly once in the second segment [1, 2].

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 7;
const long long MOD = 998244353;
const long long PIERW = 100;
int ciag[MAX];
int ostatnie[MAX];
int poprzedni[MAX];
long long pomocnicza[MAX];
long long DP[MAX];
struct Blok {
  int lewa, prawa;
  long long suma;
  long long sumaDP[PIERW * 2 + 1];
  void Aktualizuj() {
    for (int i = 0; i <= 2 * PIERW; ++i) sumaDP[i] = 0;
    suma = 0;
    for (int i = prawa; i >= lewa; --i) {
      suma += pomocnicza[i];
      sumaDP[suma + PIERW] = (sumaDP[suma + PIERW] + DP[i - 1]) % MOD;
    }
    for (int i = 1; i <= 2 * PIERW; i++)
      sumaDP[i] = (sumaDP[i] + sumaDP[i - 1]) % MOD;
  }
};
Blok bloki[MAX / PIERW + 7];
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int n, k;
  cin >> n >> k;
  DP[0] = 1;
  for (int i = 0; i * PIERW <= n; ++i) {
    bloki[i].lewa = i * PIERW + 1;
    bloki[i].prawa = (i + 1) * PIERW;
    bloki[i].Aktualizuj();
  }
  for (int i = 1; i <= n; ++i) {
    cin >> ciag[i];
    poprzedni[i] = ostatnie[ciag[i]];
    ostatnie[ciag[i]] = i;
    pomocnicza[i] = 1;
    pomocnicza[poprzedni[i]] = -1;
    int t = poprzedni[poprzedni[i]];
    pomocnicza[t] = 0;
    bloki[(i - 1) / PIERW].Aktualizuj();
    bloki[(poprzedni[i] - 1) / PIERW].Aktualizuj();
    bloki[(t - 1) / PIERW].Aktualizuj();
    int blok = (i - 1) / PIERW;
    long long suma = 0;
    for (int j = blok; j >= 0; --j) {
      int x = min(k - suma, PIERW);
      if (-PIERW <= x && x <= PIERW)
        DP[i] = (DP[i] + bloki[j].sumaDP[x + PIERW]) % MOD;
      suma += bloki[j].suma;
    }
    bloki[i / PIERW].Aktualizuj();
  }
  cout << DP[n] << "\n";
  return 0;
}

```