Problem: PolandBall is standing in a row with Many Other Balls. More precisely, there are exactly n Balls. Balls are proud of their home land — and they want to prove that it's strong.

The Balls decided to start with selecting exactly m groups of Balls, each consisting either of single Ball or two neighboring Balls. Each Ball can join no more than one group.

The Balls really want to impress their Enemies. They kindly asked you to calculate number of such divisions for all m where 1 ≤ m ≤ k. Output all these values modulo 998244353, the Enemies will be impressed anyway.

Input

There are exactly two numbers n and k (1 ≤ n ≤ 109, 1 ≤ k < 215), denoting the number of Balls and the maximim number of groups, respectively.

Output

You should output a sequence of k values. The i-th of them should represent the sought number of divisions into exactly i groups, according to PolandBall's rules.

Examples

Input

3 3


Output

5 5 1 

Input

1 1


Output

1 

Input

5 10


Output

9 25 25 9 1 0 0 0 0 0 

Note

In the first sample case we can divide Balls into groups as follows: 

{1}, {2}, {3}, {12}, {23}.

{12}{3}, {1}{23}, {1}{2}, {1}{3}, {2}{3}.

{1}{2}{3}.

Therefore, output is: 5 5 1.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
struct poly;
vector<int> rev, roots{0, 1}, Inv;
int ksm(int a, int b, int p) {
  int ans = 1;
  while (b) {
    if (b & 1) ans = 1ll * ans * a % p;
    b >>= 1, a = 1ll * a * a % p;
  }
  return ans;
}
void init(int k) {
  if (Inv.size() < k) {
    int j = Inv.size();
    Inv.resize(k + 1);
    for (int i = j; i <= k; ++i) Inv[i] = ksm(i, p - 2, p);
  }
  return;
}
void dft(vector<int> &a) {
  int n = a.size();
  if (rev.size() != n) {
    rev.resize(n);
    for (int i = 0; i < n; ++i)
      rev[i] = rev[i >> 1] >> 1 | ((i & 1) ? n >> 1 : 0);
  }
  for (int i = 0; i < n; ++i)
    if (rev[i] < i) swap(a[rev[i]], a[i]);
  if (roots.size() < n) {
    int k = roots.size();
    roots.resize(n);
    while (k < n) {
      int e = ksm(3, (p - 1) / (k << 1), p);
      for (int i = (k >> 1); i < k; ++i) {
        roots[i << 1] = roots[i];
        roots[i << 1 | 1] = 1ll * roots[i] * e % p;
      }
      k <<= 1;
    }
  }
  for (int i = 1; i < n; i <<= 1) {
    for (int j = 0; j < n; j += (i << 1)) {
      for (int k = 0; k < i; ++k) {
        int x = a[j | k], y = 1ll * a[i | j | k] * roots[i | k] % p;
        a[j | k] = ((x + y) > p ? ((x + y) - p) : x + y),
              a[i | j | k] = ((x - y + p) > p ? ((x - y + p) - p) : x - y + p);
      }
    }
  }
}
void idft(vector<int> &a) {
  dft(a);
  reverse(a.begin() + 1, a.end());
  int tmp = ksm(a.size(), p - 2, p);
  for (int i = 0; i < a.size(); ++i) a[i] = 1ll * a[i] * tmp % p;
}
void build(int l, int r, int t, const vector<int> &x, vector<poly> &tr);
void work(int l, int r, int t, poly x, vector<int> &ans,
          const vector<poly> &tr);
struct poly {
  vector<int> a;
  poly() {}
  poly(int x) {
    if (x) a = {x};
  }
  poly(const vector<int> &a0) : a(a0) {
    while (!a.empty() && !a.back()) a.pop_back();
  }
  int size() const { return a.size(); }
  int operator[](int id) const {
    if (id < 0 || id >= size()) return 0;
    return a[id];
  }
  poly modxk(int k) const {
    k = min(k, size());
    return poly(vector<int>(a.begin(), a.begin() + k));
  }
  poly divxk(int k) const {
    if (size() <= k) return poly();
    return poly(vector<int>(a.begin() + k, a.end()));
  }
  poly deriv() const {
    if (a.empty()) return poly();
    vector<int> res(size() - 1);
    for (int i = 0; i < size() - 1; ++i) res[i] = 1ll * a[i + 1] * (i + 1) % p;
    return poly(res);
  }
  poly integr() const {
    if (a.empty()) return poly();
    vector<int> res(size() + 1);
    init(size());
    for (int i = 0; i < size(); ++i) res[i + 1] = 1ll * a[i] * Inv[i + 1] % p;
    return poly(res);
  }
  friend poly operator*(poly a, poly b) {
    int len = 1, tot = a.size() + b.size() - 1;
    while (len < tot) len <<= 1;
    if (tot <= 128) {
      vector<int> c(len);
      for (int i = 0; i < a.size(); ++i)
        for (int j = 0; j < b.size(); ++j)
          c[i + j] = 1ll * (c[i + j] + 1ll * a[i] * b[j]) % p;
      return poly(c);
    }
    a.a.resize(len), b.a.resize(len);
    dft(a.a), dft(b.a);
    for (int i = 0; i < len; ++i) a.a[i] = 1ll * a[i] * b[i] % p;
    idft(a.a);
    return poly(a.a);
  }
  friend poly operator-(const poly a, const poly b) {
    vector<int> tmp(max(a.size(), b.size()));
    for (int i = 0; i < tmp.size(); ++i) {
      int x = a[i] - b[i];
      tmp[i] = ((x + p) > p ? ((x + p) - p) : x + p);
    }
    return poly(tmp);
  }
  friend poly operator+(const poly a, const poly b) {
    vector<int> tmp(max(a.size(), b.size()));
    for (int i = 0; i < tmp.size(); ++i) {
      int x = a[i] + b[i];
      tmp[i] = ((x) > p ? ((x)-p) : x);
    }
    return poly(tmp);
  }
  poly log(int len) { return (deriv() * inv(len)).integr().modxk(len); }
  poly exp(int len) {
    poly b(1);
    int k = 1;
    while (k < len) {
      k <<= 1;
      b = b * (1 - b.log(k) + modxk(k)).modxk(k);
    }
    return b.modxk(len);
  }
  poly inv(int len) const {
    poly b(ksm(a[0], p - 2, p));
    int k = 1;
    while (k < len) {
      k <<= 1;
      b = (b * (2 - modxk(k) * b)).modxk(k);
    }
    return b.modxk(len);
  }
};
struct matrix {
  poly a[2][2];
  poly *operator[](int x) { return a[x]; }
};
struct vec {
  poly a[2];
  poly &operator[](int x) { return a[x]; }
};
int n, K;
matrix mul(matrix a, matrix b) {
  matrix c;
  for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 2; ++j)
      for (int k = 0; k < 2; ++k)
        c[i][j] = (c[i][j] + (a[i][k] * b[k][j]).modxk(K));
  return c;
}
vec mul(vec a, matrix b) {
  vec c;
  for (int i = 0; i < 2; ++i)
    for (int j = 0; j < 2; ++j) c[i] = (c[i] + (a[j] * b[i][j]).modxk(K));
  return c;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  cin >> n >> K;
  ++K;
  vec ans;
  ans.a[0] = vector<int>{1};
  matrix b;
  b[0][1] = poly{vector<int>{0, 1}};
  b[0][0] = poly{vector<int>{1, 1}};
  b[1][0] = poly{vector<int>{1}};
  while (n) {
    if (n & 1) ans = mul(ans, b);
    n >>= 1, b = mul(b, b);
  }
  ans.a[0] = ans.a[0].divxk(1);
  for (auto x : ans.a[0].a) cout << x << ' ';
  int st = ans.a[0].size();
  for (int i = st + 1; i < K; ++i) cout << 0 << ' ';
  cout << '\n';
  return 0;
}