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 JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Jialin Ouyang (Jialin.Ouyang@gmail.com)
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    QuickScanner in = new QuickScanner(inputStream);
    QuickWriter out = new QuickWriter(outputStream);
    TaskG solver = new TaskG();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskG {
    static IntModular MOD = new IntModular(998244353);
    FourierTransformerModular FFT;
    int n;
    int m;
    int k;
    int[][][] way;
    int[] aa;
    int[] bb;
    int[] cc;
    int[] ab;
    int[] bc;
    static int BOUND = 1000;

    public void solve(int testNumber, QuickScanner in, QuickWriter out) {
      FFT = new FourierTransformerModular(MOD.mod, 31);
      n = in.nextInt();
      k = in.nextInt();
      int k2 = k << 1;
      m = Integer.highestOneBit(k2);
      if (m <= k2) m <<= 1;
      way = new int[2][4][m];
      aa = new int[m];
      bb = new int[m];
      cc = new int[m];
      ab = new int[m];
      bc = new int[m];
      int idx = calc(0, n);
      int[] res = way[0][idx];
      out.print(res[1]);
      for (int i = 2; i <= k; ++i) {
        out.print(' ');
        out.print(res[i]);
      }
      out.println();
    }

    int calc(int x, int n) {
      if (n <= BOUND) {
        return calcSmall(n, way[x]);
      }
      int yC = calc(x ^ 1, n >> 1);
      int yA = (yC + 2) & 3, yB = (yC + 3) & 3;
      int[] prevA = way[x ^ 1][yA], prevB = way[x ^ 1][yB], prevC = way[x ^ 1][yC];
      FFT.fft(m, prevA, false);
      FFT.fft(m, prevB, false);
      FFT.fft(m, prevC, false);
      for (int i = 0; i < m; ++i) {
        aa[i] = MOD.mul(prevA[i], prevA[i]);
        bb[i] = MOD.mul(prevB[i], prevB[i]);
        cc[i] = MOD.mul(prevC[i], prevC[i]);
        ab[i] = MOD.mul(prevA[i], prevB[i]);
        bc[i] = MOD.mul(prevB[i], prevC[i]);
      }
      FFT.fft(m, aa, true);
      FFT.fft(m, bb, true);
      FFT.fft(m, cc, true);
      FFT.fft(m, ab, true);
      FFT.fft(m, bc, true);
      int[] curA = way[x][0], curB = way[x][1], curC = way[x][2];
      Arrays.fill(curA, 0);
      Arrays.fill(curB, 0);
      Arrays.fill(curC, 0);
      for (int i = Math.min(m - 1, k); i >= 0; --i) {
        curA[i] = MOD.add(bb[i], i > 0 ? aa[i - 1] : 0);
        curB[i] = MOD.add(bc[i], i > 0 ? ab[i - 1] : 0);
        curC[i] = MOD.add(cc[i], i > 0 ? bb[i - 1] : 0);
      }
      if ((n & 1) > 0) {
        merge(way[x][3], way[x][1], way[x][2]);
        return 3;
      } else {
        return 2;
      }
    }

    int calcSmall(int n, int[][] way) {
      Arrays.fill(way[0], 0);
      Arrays.fill(way[1], 0);
      way[0][0] = way[1][0] = way[1][1] = 1;
      int a = 0;
      for (int i = 2; i <= n; ++i, a = (a + 1) & 3) {
        merge(way[(a + 2) & 3], way[a], way[(a + 1) & 3]);
      }
      return (a + 1) & 3;
    }

    void merge(int[] resWay, int[] way2, int[] way1) {
      Arrays.fill(resWay, 0);
      for (int i = Math.min(m - 1, k); i >= 0; --i) {
        // leave empty
        int curRes = way1[i];
        // take 1
        if (i > 0) {
          curRes = MOD.add(curRes, way1[i - 1]);
        }
        // take 2
        if (i > 0) {
          curRes = MOD.add(curRes, way2[i - 1]);
        }
        resWay[i] = curRes;
      }
    }

  }

  static class IntArrayUtils {
    public static void swap(int[] values, int uIdx, int vIdx) {
      if (uIdx == vIdx) return;
      values[uIdx] ^= values[vIdx];
      values[vIdx] ^= values[uIdx];
      values[uIdx] ^= values[vIdx];
    }

  }

  static class QuickScanner {
    private static final int BUFFER_SIZE = 1024;
    private InputStream stream;
    private byte[] buffer;
    private int currentPosition;
    private int numberOfChars;

    public QuickScanner(InputStream stream) {
      this.stream = stream;
      this.buffer = new byte[BUFFER_SIZE];
      this.currentPosition = 0;
      this.numberOfChars = 0;
    }

    public int nextInt() {
      int c = nextNonSpaceChar();
      boolean positive = true;
      if (c == '-') {
        positive = false;
        c = nextChar();
      }
      int res = 0;
      do {
        if (c < '0' || '9' < c) throw new RuntimeException();
        res = res * 10 + c - '0';
        c = nextChar();
      } while (!isSpaceChar(c));
      return positive ? res : -res;
    }

    public int nextNonSpaceChar() {
      int res = nextChar();
      for (; isSpaceChar(res) || res < 0; res = nextChar()) ;
      return res;
    }

    public int nextChar() {
      if (numberOfChars == -1) {
        throw new RuntimeException();
      }
      if (currentPosition >= numberOfChars) {
        currentPosition = 0;
        try {
          numberOfChars = stream.read(buffer);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
        if (numberOfChars <= 0) {
          return -1;
        }
      }
      return buffer[currentPosition++];
    }

    public boolean isSpaceChar(int c) {
      return c == ' ' || c == '\t' || isEndOfLineChar(c);
    }

    public boolean isEndOfLineChar(int c) {
      return c == '\n' || c == '\r' || c < 0;
    }

  }

  static class QuickWriter {
    private final PrintWriter writer;

    public QuickWriter(OutputStream outputStream) {
      this.writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public QuickWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
      for (int i = 0; i < objects.length; ++i) {
        if (i > 0) {
          writer.print(' ');
        }
        writer.print(objects[i]);
      }
    }

    public void println(Object... objects) {
      print(objects);
      writer.print('\n');
    }

    public void close() {
      writer.close();
    }

  }

  static class IntModular {
    private static final int MOD = 1000000007;
    public final int mod;
    private final int[] x;

    public IntModular() {
      this(MOD);
    }

    public IntModular(int mod) {
      this.mod = mod;
      this.x = new int[2];
    }

    public int add(int a, int b) {
      return slightFix(a + b);
    }

    public int sub(int a, int b) {
      return slightFix(a - b);
    }

    public int fix(int a) {
      a = slightFix(a);
      return 0 <= a && a < mod ? a : slightFix(a % mod);
    }

    public int mul(int a, int b) {
      return a > 0
          ? (b < mod / a ? a * b : (int) ((long) a * b % mod))
          : 0;
    }

    public int pow(int a, long b) {
      int res = 1;
      for (; b > 0; b >>= 1, a = mul(a, a))
        if ((b & 1) > 0) {
          res = mul(res, a);
        }
      return res >= mod ? fix(res) : res;
    }

    public int inverse(int a) {
      if (extGcd(a, mod, x) != 1) {
        throw new IllegalArgumentException();
      }
      return slightFix(x[0]);
    }

    public int extGcd(int a, int b, int[] x) {
      if (b == 0) {
        x[0] = 1;
        x[1] = 0;
        return a;
      }
      int gcd = extGcd(b, a % b, x);
      IntArrayUtils.swap(x, 0, 1);
      x[1] -= a / b * x[0];
      return gcd;
    }

    private int slightFix(int a) {
      return a >= mod
          ? a - mod
          : a < 0 ? a + mod : a;
    }

  }

  static class FourierTransformerModular {
    private final int root;
    private final int invRoot;
    private final int rootExp;
    private final IntModular MOD;

    public FourierTransformerModular(int mod, int root) {
      this.rootExp = Integer.lowestOneBit(mod - 1);
      this.MOD = new IntModular(mod);
      if (MOD.pow(root, rootExp) != 1) {
        throw new IllegalArgumentException(String.format("%d^%d != 1 (mod %d)", root, rootExp, mod));
      }
      this.root = root;
      this.invRoot = MOD.inverse(root);
    }

    public void fft(int n, int[] a, boolean invert) {
      if (Integer.bitCount(n) != 1) {
        throw new IllegalArgumentException(n + " should be pow of 2.");
      }
      for (int i = 1, j = 0; i < n; ++i) {
        int bit = n >> 1;
        for (; j >= bit; bit >>= 1) j -= bit;
        j += bit;
        if (i < j) IntArrayUtils.swap(a, i, j);
      }
      for (int len = 2; len <= n; len <<= 1) {
        int len2 = len >> 1;
        int wBase = invert ? invRoot : root;
        for (int i = len; i < rootExp; i <<= 1) {
          wBase = MOD.mul(wBase, wBase);
        }
        for (int i = 0; i < n; i += len) {
          int w = 1;
          for (int j = 0; j < len2; ++j) {
            int u = a[i + j], v = MOD.mul(a[i + j + len2], w);
            a[i + j] = MOD.add(u, v);
            a[i + j + len2] = MOD.sub(u, v);
            w = MOD.mul(w, wBase);
          }
        }
      }
      if (invert) {
        int invN = MOD.inverse(n);
        for (int i = 0; i < n; ++i) {
          a[i] = MOD.mul(a[i], invN);
        }
      }
    }

  }
}