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.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;

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

    static class TaskG {
        final int mod = 998244353;
        final int rootPower = 1 << 23;
        final int root = 31;
        final int reverseRoot = (int) IntegerUtils.reverse(root, mod);
        int maxK;
        int[][] dp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int maxN;

            maxN = in.readInt();
            maxK = in.readInt();

            dp = new int[4][maxK + 1];
            dp[0][0] = 1;
            for (int n = 1; n < dp.length; n++) {
                for (int k = 0; k <= maxK; k++) {
                    int res = dp[n - 1][k];
                    if (0 <= k - 1) {
                        res += dp[n - 1][k - 1];
                        if (mod <= res) {
                            res -= mod;
                        }
                        if (0 <= n - 2) {
                            res += dp[n - 2][k - 1];
                            if (mod <= res) {
                                res -= mod;
                            }
                        }
                    }
                    dp[n][k] = res;
                }
            }
            int[] answer;
            if (maxN < dp.length) {
                answer = dp[maxN];
            } else {
                ArrayList<int[]> f = f(maxN);
                answer = f.get(0);
            }
            for (int i = 1; i <= maxK; i++) {
//            if (answer[i] != dp[maxN][i]) {
//                throw new RuntimeException();
//            }
                out.print(" " + answer[i]);
            }
            out.printLine();
        }

        private ArrayList<int[]> f(int n) {
            ArrayList<int[]> res = new ArrayList<>(3);
            if (n < dp.length) {
                res.add(dp[n]);
                res.add(dp[n - 1]);
                res.add(dp[n - 2]);
            } else {
                if (n % 2 == 1) {
                    ArrayList<int[]> prev = f(n - 1);
                    int[] dpn = new int[maxK + 1];
                    int[] dpn1 = prev.get(0);
                    int[] dpn2 = prev.get(1);
                    for (int k = 0; k <= maxK; k++) {
                        int dpnk = dpn1[k];
                        if (0 <= k - 1) {
                            dpnk += dpn1[k - 1];
                            if (mod <= dpnk) {
                                dpnk -= mod;
                            }
                            if (0 <= n - 2) {
                                dpnk += dpn2[k - 1];
                                if (mod <= dpnk) {
                                    dpnk -= mod;
                                }
                            }
                        }
                        if (mod <= dpnk) {
                            dpnk -= mod;
                        }
                        dpn[k] = dpnk;
                    }
                    res.add(dpn);
                    res.add(dpn1);
                    res.add(dpn2);
                } else {
                    ArrayList<int[]> prev = f(n / 2);
                    int[] dpn = prev.get(0);
                    int[] dpn1 = prev.get(1);
                    int[] dpn2 = prev.get(2);

//                int resultSize = Math.max(4, Integer.highestOneBit(maxK) << 2);
                    int resultSize = 1 << 16;
                    dpn = Arrays.copyOf(dpn, resultSize);
                    dpn1 = Arrays.copyOf(dpn1, resultSize);
                    dpn2 = Arrays.copyOf(dpn2, resultSize);
                    fft(dpn, false, resultSize);
                    fft(dpn1, false, resultSize);
                    fft(dpn2, false, resultSize);


                    int[] ints = multFFT(dpn1, dpn1);
                    res.add(addShift(multFFT(dpn, dpn), ints));
                    res.add(addShift(multFFT(dpn, dpn1), multFFT(dpn1, dpn2)));
                    res.add(addShift(ints, multFFT(dpn2, dpn2)));
                }
            }
            return res;
        }

        private int[] multFFT(int[] a, int[] b) {
            int[] res = new int[a.length];
            for (int i = 0; i < a.length; i++) {
                res[i] = (int) ((long) a[i] * b[i] % mod);
            }
            fft(res, true, res.length);
            return Arrays.copyOf(res, maxK + 1);
        }

        private int[] addShift(int[] a, int[] b) {
            int[] c = new int[maxK + 1];
            for (int i = 0; i <= maxK; i++) {
                c[i] = (a[i] + (0 <= i - 1 ? b[i - 1] : 0));
                if (mod <= c[i]) {
                    c[i] -= mod;
                }
            }
            return c;
        }

        private void fft(int[] array, boolean invert, int size) {
            for (int i = 1, j = 0; i < size; ++i) {
                int bit = size >> 1;
                for (; j >= bit; bit >>= 1) {
                    j -= bit;
                }
                j += bit;
                if (i < j) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }

            for (int len = 2; len <= size; len <<= 1) {
                int wlen = invert ? reverseRoot : root;
                for (int i = len; i < rootPower; i <<= 1) {
                    wlen = (int) ((long) wlen * wlen % mod);
                }
                int half = len >> 1;
                for (int i = 0; i < size; i += len) {
                    int w = 1;
                    for (int j = 0; j < half; ++j) {
                        int u = array[i + j];
                        int v = (int) ((long) array[i + j + half] * w % mod);
                        array[i + j] = u + v < mod ? u + v : u + v - mod;
                        array[i + j + half] = u - v >= 0 ? u - v : u - v + mod;
                        w = (int) ((long) w * wlen % mod);
                    }
                }
            }
            if (invert) {
                int reverseSize = (int) IntegerUtils.reverse(size, mod);
                for (int i = 0; i < size; ++i) {
                    array[i] = (int) ((long) array[i] * reverseSize % mod);
                }
            }
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(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 printLine() {
            writer.println();
        }

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

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if ((c < '0') || (c > '9')) {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return (c == ' ') || (c == '\n') || (c == '\r') || (c == '\t') || (c == -1);
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class IntegerUtils {
        public static long power(long base, long exponent, long mod) {
            if (base >= mod) {
                base %= mod;
            }
            if (exponent == 0) {
                return 1 % mod;
            }
            long result = power(base, exponent >> 1, mod);
            result = (result * result) % mod;
            if ((exponent & 1) != 0) {
                result = (result * base) % mod;
            }
            return result;
        }

        public static long reverse(long number, long module) {
            return power(number, module - 2, module);
        }

    }
}