import java.io.*;
import java.util.*;

public class Main {
    private static class Solver {
        private void Solve() {
            int n = inp.nextInt();
            int k = inp.nextInt();

            int[][] dp1 = new int[n + 1][n + 1];
            int[][] dp2 = new int[n + 1][n + 1];

            final int MOD = 998244353;
            int ans = 0;
            for (int l = 1; l <= n; ++l) {
                for (int i = 1; i <= n; ++i) {
                    for (int j = 1; j <= i; ++j) {
                        dp1[i][j] = 0;
                        dp2[i][j] = 0;
                    }
                }
                dp1[1][1] = 1;
                for (int i = 1; i <= n - 1; ++i) {
                    for (int j = 1; j <= l; ++j) {
                        if (j + 1 <= l) {
                            dp1[i + 1][j + 1] += dp1[i][j];
                            if (dp1[i + 1][j + 1] >= MOD) {
                                dp1[i + 1][j + 1] -= MOD;
                            }
                        }
                        dp1[i + 1][1] += dp1[i][j];
                        if (dp1[i + 1][1] >= MOD) {
                            dp1[i + 1][1] -= MOD;
                        }
                    }
                }
                dp2[1][1] = 1;
                for (int i = 1; i <= n - 1; ++i) {
                    for (int j = 1; j <= l - 1; ++j) {
                        if (j + 1 <= l - 1) {
                            dp2[i + 1][j + 1] += dp2[i][j];
                            if (dp2[i + 1][j + 1] >= MOD) {
                                dp2[i + 1][j + 1] -= MOD;
                            }
                        }
                        dp2[i + 1][1] += dp2[i][j];
                        if (dp2[i + 1][1] >= MOD) {
                            dp2[i + 1][1] -= MOD;
                        }
                    }
                }

                int coef = 0;
                for (int i = 1; i <= l; ++i) {
                    coef = (coef + dp1[n][i]) % MOD;
                }
                for (int i = 1; i <= l - 1; ++i) {
                    coef = (coef - dp2[n][i] + MOD) % MOD;
                }

                int[] f = new int[n + 1];
                for (int i = 1; i <= n; ++i) {
                    f[i] = (i * l < k) ? 2 : 0;
                    for (int j = i; j >= 2 && (i - j + 1) * l < k; --j) {
                        f[i] += f[j - 1];
                        if (f[i] >= MOD) {
                            f[i] -= MOD;
                        }
                    }
                }
                ans = (int) ((ans + (long) f[n] * coef) % MOD);
            }

            out.println(ans);
        }

        static InputReader inp;
        static PrintWriter out;
    }

    private static class InputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer;

        private InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        private String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        private int nextInt() {
            return Integer.parseInt(next());
        }

        private long nextLong() {
            return Long.parseLong(next());
        }

        private double nextDouble() {
            return Double.parseDouble(next());
        }

    }

    public static void main(String[] args) throws IOException {
        if (!"true".equals(System.getProperty("ONLINE_JUDGE"))) {
            System.setIn(new FileInputStream(new File("input.txt")));
        }
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Solver.inp = new InputReader(inputStream);
        Solver.out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        solver.Solve();
        Solver.out.close();
    }

}