#include <bits/stdc++.h>
using namespace std;
template <int m>
class mod {
  static_assert(m > 0, "mod must be positive");

 private:
  using ll = long long;
  int v;
  static int minv(int a, int b = m) {
    return a == 1 ? 1 : b - ll(minv(b % a, a)) * b / a;
  }

 public:
  mod() : v(0) {}
  mod(int v_) : v(-m <= v_ && v_ < m ? v_ : v_ % m) {
    if (v < 0) v += m;
  }
  explicit operator int() { return v; }
  friend ostream &operator<<(ostream &os, const mod &a) { return os << a.v; }
  friend istream &operator>>(istream &is, mod &a) {
    ll v;
    is >> v;
    a = mod(v);
    return is;
  }
  bool operator==(const mod &a) { return v == a.v; }
  bool operator!=(const mod &a) { return v != a.v; }
  mod inv() const {
    assert(v);
    return minv(v);
  }
  mod operator+() const { return *this; }
  mod operator-() const {
    mod a;
    a.v = (v ? m - v : 0);
    return a;
  }
  mod &operator+=(const mod &a) {
    if ((v += a.v) >= m) v -= m;
    return *this;
  }
  mod &operator-=(const mod &a) {
    if ((v -= a.v) < 0) v += m;
    return *this;
  }
  mod &operator*=(const mod &a) {
    v = ll(v) * a.v % m;
    return *this;
  }
  mod &operator/=(const mod &a) { return *this *= a.inv(); }
  mod operator+(const mod &a) const { return mod(*this) += a; }
  mod operator-(const mod &a) const { return mod(*this) -= a; }
  mod operator*(const mod &a) const { return mod(*this) *= a; }
  mod operator/(const mod &a) const { return mod(*this) /= a; }
  mod &operator++() {
    if (++v == m) v = 0;
    return *this;
  }
  mod &operator--() {
    v = (v ? v - 1 : m - 1);
    return *this;
  }
  mod operator++(int) {
    mod a(*this);
    operator++();
    return a;
  }
  mod operator--(int) {
    mod a(*this);
    operator--();
    return a;
  }
  mod pow(int b) const {
    mod a(*this), c(1);
    while (b) {
      if (b & 1) c *= a;
      a *= a;
      b /= 2;
    }
    return c;
  }
};
template <class t>
ostream &operator<<(ostream &os, const vector<t> &v) {
  for (int i = 0; i < v.size(); i++) {
    if (i) cout << " ";
    cout << v[i];
  }
  return os;
}
const int N = 3007, C = 3007;
using num = mod<998244353>;
int n, c, a[N];
num p2[N], p2i[N], p2m1[N], p2m1i[N], ans[N];
vector<num> dp[N];
void precomp(int n) {
  p2[0] = p2i[0] = 1;
  for (int i = 1; i <= n; i++) {
    p2[i] = p2[i - 1] * 2;
    p2m1[i] = p2[i] - 1;
    p2i[i] = p2[i].inv();
    p2m1i[i] = p2m1[i].inv();
  }
}
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cin >> n >> c;
  precomp(n);
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    --a[i];
  }
  dp[0] = {1};
  if (c < 10) {
    vector<vector<num>> u(1 << c);
    u[0] = {1};
    int all = (1 << c) - 1;
    for (int i = 1; i <= n; i++) {
      int flag = 1 << a[i - 1];
      for (int m = all - 1; m >= 0; m--) {
        int m1 = m | flag, k = u[m].size();
        if (u[m1].size() < k) u[m1].resize(k);
        for (int t = 0; t < k; t++) {
          u[m1][t] += u[m][t];
        }
      }
      dp[i] = u[all & ~flag];
      dp[i].insert(dp[i].begin(), 0);
      int k = u[all].size();
      if (u[0].size() <= k) u[0].resize(k + 1);
      for (int t = 0; t < k; t++) {
        u[0][t + 1] += u[all][t];
      }
      u[all].clear();
    }
  } else {
    for (int j = 1; j <= n; j++) {
      vector<int> cnt(c);
      int missing = c;
      num prod = 1;
      for (int i = j - 1; i >= 0; i--) {
        if (cnt[a[i]] != 0) {
          prod *= p2m1i[cnt[a[i]]];
        } else {
          missing--;
        }
        cnt[a[i]]++;
        prod *= p2m1[cnt[a[i]]];
        if (!missing) {
          num ways = prod * p2m1i[cnt[a[j - 1]]];
          int k = dp[i].size();
          if (dp[j].size() <= k) dp[j].resize(k + 1);
          for (int t = 0; t < k; t++) {
            dp[j][t + 1] += dp[i][t] * ways;
          }
        }
      }
    }
  }
  for (int i = 0; i <= n; i++) {
    for (int t = 0; t < dp[i].size(); t++) {
      ans[t] += dp[i][t] * p2[n - i];
    }
  }
  for (int t = 0; t < n; t++) {
    ans[t] -= ans[t + 1];
  }
  ans[0] -= 1;
  for (int i = 0; i <= n; i++) {
    cout << ans[i] << " \n"[i == n];
  }
}
