#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
struct Mint {
  int val;
  Mint() { val = 0; }
  Mint(const long long& x) {
    val = (-MOD <= x && x < MOD) ? x : x % MOD;
    if (val < 0) val += MOD;
  }
  template <typename U>
  explicit operator U() const {
    return (U)val;
  }
  friend bool operator==(const Mint& a, const Mint& b) {
    return a.val == b.val;
  }
  friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
  friend bool operator<(const Mint& a, const Mint& b) { return a.val < b.val; }
  Mint& operator+=(const Mint& m) {
    if ((val += m.val) >= MOD) val -= MOD;
    return *this;
  }
  Mint& operator-=(const Mint& m) {
    if ((val -= m.val) < 0) val += MOD;
    return *this;
  }
  Mint& operator*=(const Mint& m) {
    val = (long long)val * m.val % MOD;
    return *this;
  }
  friend Mint modex(Mint a, long long p) {
    assert(p >= 0);
    Mint ans = 1;
    for (; p; p >>= 1, a *= a)
      if (p & 1) ans *= a;
    return ans;
  }
  Mint& operator/=(const Mint& m) { return *this *= modex(m, MOD - 2); }
  Mint& operator++() { return *this += 1; }
  Mint& operator--() { return *this -= 1; }
  Mint operator++(int) {
    Mint result(*this);
    *this += 1;
    return result;
  }
  Mint operator--(int) {
    Mint result(*this);
    *this -= 1;
    return result;
  }
  Mint operator-() const { return Mint(-val); }
  friend Mint operator+(Mint a, const Mint& b) { return a += b; }
  friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
  friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
  friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
  friend ostream& operator<<(ostream& os, const Mint& x) { return os << x.val; }
  friend string to_string(const Mint& b) { return to_string(b.val); }
};
const int MAXN = 25;
Mint fac[MAXN], invfac[MAXN];
int main() {
  fac[0] = 1;
  for (int i = 1; i < MAXN; ++i) fac[i] = fac[i - 1] * i;
  invfac[MAXN - 1] = 1 / fac[MAXN - 1];
  for (int i = MAXN - 2; i >= 0; --i) invfac[i] = invfac[i + 1] * (i + 1);
  int n, k, c;
  scanf("%d%d%d", &n, &k, &c);
  vector<map<int, int>> vals(c + 1);
  int xa = 0;
  for (int i = 0; i < n; ++i) {
    int a;
    scanf("%d", &a);
    int bits = 0;
    while ((((1 << bits) - 1) & a) < k) ++bits;
    42;
    vals[bits][((1 << bits) - 1) & a]++;
    xa ^= a;
  }
  vector<vector<Mint>> dp(1, vector<Mint>(k + 1));
  dp[0][0] = 1;
  for (int i = 1; i <= c; ++i) {
    for (auto& v : vals[i]) {
      42;
      int a = v.first;
      assert(a >= k && a < (1 << i));
      dp.resize(1 << i, vector<Mint>(k + 1));
      for (int t = 0; t < v.second; ++t) {
        vector<vector<Mint>> ndp(1 << i, vector<Mint>(k + 1));
        for (int j = 0; j < (1 << i); ++j) {
          for (int cur = 0; cur <= k; ++cur)
            for (int take = 0; take <= cur; ++take) {
              ndp[j][cur] +=
                  dp[j ^ (a ^ (a - take))][cur - take] * invfac[take];
            }
        }
        swap(dp, ndp);
      }
    }
  }
  dp.resize(1 << c, vector<Mint>(k + 1));
  Mint inv = 1 / modex(Mint(n), k);
  for (int i = 0; i < (1 << c); ++i) {
    Mint ans = dp[xa ^ i][k] * fac[k] * inv;
    printf("%d ", ans.val);
  }
}

### Prompt

Please formulate a cpp solution to the following problem:

You are given a positive integer k and an array a_1, a_2, …, a_n of non-negative distinct integers not smaller than k and not greater than 2^c-1.

In each of the next k seconds, one element is chosen randomly equiprobably out of all n elements and decreased by 1.

For each integer x, 0 ≤ x ≤ 2^c - 1, you need to find the probability that in the end the bitwise XOR of all elements of the array is equal to x. 

Each of these values can be represented as an irreducible fraction p/q, and you need to find the value of p ⋅ q^{-1} modulo 998 244 353. 

Input

The first line of input contains three integers n, k, c (1 ≤ n ≤ (2^c - k), 1 ≤ k ≤ 16, 1 ≤ c ≤ 16).

The second line contains n distinct integers a_1, a_2, …, a_n (k ≤ a_i ≤ 2^c-1).

Output

Print 2^c integers: the probability that the bitwise XOR is equal to x in the end for x in \{0, 1, …, 2^c-1\} modulo 998 244 353.

Example

Input


4 1 3
1 2 3 4


Output


0 0 0 748683265 0 499122177 0 748683265 

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
struct Mint {
  int val;
  Mint() { val = 0; }
  Mint(const long long& x) {
    val = (-MOD <= x && x < MOD) ? x : x % MOD;
    if (val < 0) val += MOD;
  }
  template <typename U>
  explicit operator U() const {
    return (U)val;
  }
  friend bool operator==(const Mint& a, const Mint& b) {
    return a.val == b.val;
  }
  friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
  friend bool operator<(const Mint& a, const Mint& b) { return a.val < b.val; }
  Mint& operator+=(const Mint& m) {
    if ((val += m.val) >= MOD) val -= MOD;
    return *this;
  }
  Mint& operator-=(const Mint& m) {
    if ((val -= m.val) < 0) val += MOD;
    return *this;
  }
  Mint& operator*=(const Mint& m) {
    val = (long long)val * m.val % MOD;
    return *this;
  }
  friend Mint modex(Mint a, long long p) {
    assert(p >= 0);
    Mint ans = 1;
    for (; p; p >>= 1, a *= a)
      if (p & 1) ans *= a;
    return ans;
  }
  Mint& operator/=(const Mint& m) { return *this *= modex(m, MOD - 2); }
  Mint& operator++() { return *this += 1; }
  Mint& operator--() { return *this -= 1; }
  Mint operator++(int) {
    Mint result(*this);
    *this += 1;
    return result;
  }
  Mint operator--(int) {
    Mint result(*this);
    *this -= 1;
    return result;
  }
  Mint operator-() const { return Mint(-val); }
  friend Mint operator+(Mint a, const Mint& b) { return a += b; }
  friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
  friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
  friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
  friend ostream& operator<<(ostream& os, const Mint& x) { return os << x.val; }
  friend string to_string(const Mint& b) { return to_string(b.val); }
};
const int MAXN = 25;
Mint fac[MAXN], invfac[MAXN];
int main() {
  fac[0] = 1;
  for (int i = 1; i < MAXN; ++i) fac[i] = fac[i - 1] * i;
  invfac[MAXN - 1] = 1 / fac[MAXN - 1];
  for (int i = MAXN - 2; i >= 0; --i) invfac[i] = invfac[i + 1] * (i + 1);
  int n, k, c;
  scanf("%d%d%d", &n, &k, &c);
  vector<map<int, int>> vals(c + 1);
  int xa = 0;
  for (int i = 0; i < n; ++i) {
    int a;
    scanf("%d", &a);
    int bits = 0;
    while ((((1 << bits) - 1) & a) < k) ++bits;
    42;
    vals[bits][((1 << bits) - 1) & a]++;
    xa ^= a;
  }
  vector<vector<Mint>> dp(1, vector<Mint>(k + 1));
  dp[0][0] = 1;
  for (int i = 1; i <= c; ++i) {
    for (auto& v : vals[i]) {
      42;
      int a = v.first;
      assert(a >= k && a < (1 << i));
      dp.resize(1 << i, vector<Mint>(k + 1));
      for (int t = 0; t < v.second; ++t) {
        vector<vector<Mint>> ndp(1 << i, vector<Mint>(k + 1));
        for (int j = 0; j < (1 << i); ++j) {
          for (int cur = 0; cur <= k; ++cur)
            for (int take = 0; take <= cur; ++take) {
              ndp[j][cur] +=
                  dp[j ^ (a ^ (a - take))][cur - take] * invfac[take];
            }
        }
        swap(dp, ndp);
      }
    }
  }
  dp.resize(1 << c, vector<Mint>(k + 1));
  Mint inv = 1 / modex(Mint(n), k);
  for (int i = 0; i < (1 << c); ++i) {
    Mint ans = dp[xa ^ i][k] * fac[k] * inv;
    printf("%d ", ans.val);
  }
}

```