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.io.PrintStream;
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 m;
    int k;
    int[][] coef;
    int[] tmp1;
    int[] tmp2;
    int[] tmp11;
    int[] tmp22;
    int[] tmp12;

    public void solve(int testNumber, QuickScanner in, QuickWriter out) {
      FFT = new FourierTransformerModular(MOD.mod, 31);
      int n = in.nextInt();
      k = in.nextInt();
      m = IntUtils.nextPow2((k << 1) | 1);
      create();
      int idx = calc(n);
      merge(coef[idx], coef[(idx + 1) & 3], coef[(idx + 2) & 3]);
      int[] res = coef[(idx + 2) & 3];
      out.print(res[1]);
      for (int i = 2; i <= k; ++i) {
        out.print(' ');
        out.print(res[i]);
      }
      out.println();
    }

    void create() {
      coef = new int[4][m];
      tmp1 = new int[m];
      tmp2 = new int[m];
      tmp11 = new int[m];
      tmp12 = new int[m];
      tmp22 = new int[m];
    }

    int calc(int n) {
      if (n == 1) {
        int[] a = coef[0], b = coef[1];
        Arrays.fill(a, 0, m, 0);
        Arrays.fill(b, 1, m, 0);
        b[0] = 1;
        return 0;
      }
      if ((n & 1) > 0) {
        int idx = calc(n - 1);
        merge(coef[idx], coef[(idx + 1) & 3], coef[(idx + 2) & 3]);
        return (idx + 1) & 3;
      } else {
        int idx = calc(n >> 1);
        int size = Math.min(m, IntUtils.nextPow2(n));
        int[] a = coef[idx], b = coef[(idx + 1) & 3], c = coef[(idx + 2) & 3], d = coef[(idx + 3) & 3];
        for (int i = 0; i < m; ++i) {
          tmp1[i] = a[i];
          tmp2[i] = b[i];
        }
        FFT.fft(size, tmp1, false);
        FFT.fft(size, tmp2, false);
        FFT.pointwiseProduct(size, tmp1, tmp1, tmp11);
        FFT.pointwiseProduct(size, tmp1, tmp2, tmp12);
        FFT.pointwiseProduct(size, tmp2, tmp2, tmp22);
        FFT.fft(size, tmp11, true);
        FFT.fft(size, tmp12, true);
        FFT.fft(size, tmp22, true);
        Arrays.fill(c, k + 1, m, 0);
        Arrays.fill(d, k + 1, m, 0);
        c[0] = d[0] = 1;
        for (int i = 1; i <= k; ++i) {
          c[i] = MOD.add(tmp22[i], tmp11[i - 1]);
          d[i] = MOD.add(MOD.add(MOD.add(tmp22[i], tmp22[i - 1]), tmp12[i - 1]), tmp12[i - 1]);
        }
        return (idx + 2) & 3;
      }
    }

    void merge(int[] a, int[] b, int[] c) {
      Arrays.fill(c, k + 1, m, 0);
      c[0] = 1;
      for (int i = 1; i <= k; ++i) {
        c[i] = MOD.add(MOD.add(b[i], b[i - 1]), a[i - 1]);
      }
    }

  }

  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 FourierTransformerModular {
    private static final int MAXBIT = 30;
    private static final int[][] REV = new int[MAXBIT][];
    private final int[] roots;
    private final int[] invRoots;
    private final IntModular MOD;

    public FourierTransformerModular(int mod, int rootStart) {
      this(new IntModular(mod), rootStart);
    }

    public FourierTransformerModular(int mod) {
      this(new IntModular(mod));
    }

    public FourierTransformerModular(IntModular MOD) {
      this(MOD, rootStart(MOD));
    }

    public FourierTransformerModular(IntModular MOD, int rootStart) {
      if (MOD.pow(rootStart, (MOD.mod - 1) >> 1) == 1) throw new IllegalArgumentException();
      this.MOD = MOD;
      int rootCnt = Integer.numberOfTrailingZeros(MOD.mod - 1);
      roots = new int[rootCnt];
      invRoots = new int[rootCnt];
      for (int i = 0, exp = MOD.mod - 1; i < rootCnt; ++i, exp >>= 1) {
        roots[i] = MOD.pow(rootStart, exp);
        invRoots[i] = MOD.inverse(roots[i]);
      }
    }

    public void fft(int n, int[] a, boolean invert) {
      if (!IntUtils.isPow2(n)) throw new IllegalArgumentException();
      int[] rev = initRev(n);
      for (int i = 1; i < n; ++i)
        if (i < rev[i]) {
          IntArrayUtils.swap(a, i, rev[i]);
        }
      for (int len = 2, idx = 1; len <= n; len <<= 1, ++idx) {
        int len2 = len >> 1;
        int wBase = invert ? invRoots[idx] : roots[idx];
//      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);
        }
      }
    }

    public void pointwiseProduct(int n, int[] a, int[] b, int[] res) {
      for (int i = 0; i < n; ++i) {
        res[i] = MOD.mul(a[i], b[i]);
      }
    }

    private int[] initRev(int n) {
      int nBit = Integer.numberOfTrailingZeros(n);
      if (REV[nBit] != null) return REV[nBit];
      REV[nBit] = new int[n];
      int[] rev = REV[nBit];
      for (int i = 1, j = 0; i < n; ++i) {
        int bit = n >> 1;
        for (; j >= bit; bit >>= 1) j -= bit;
        j += bit;
        rev[i] = j;
      }
      return rev;
    }

    private static int rootStart(IntModular MOD) {
      int exp = (MOD.mod - 1) >> 1;
      for (int i = 2; ; ++i)
        if (MOD.pow(i, exp) != 1) {
          System.err.printf("mod:%d rootStart:%d\n", MOD.mod, i);
          return i;
        }
    }

  }

  static class IntUtils {
    public static boolean isPow2(int n) {
      return n > 0 && (n & (n - 1)) == 0;
    }

    public static int nextPow2(int n) {
      if (n < 1) return 1;
      return isPow2(n) ? n : Integer.highestOneBit(n) << 1;
    }

  }

  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 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];
    }

  }
}