You are given a square board, consisting of $$$n$$$ rows and $$$n$$$ columns. Each tile in it should be colored either white or black.Let's call some coloring beautiful if each pair of adjacent rows are either the same or different in every position. The same condition should be held for the columns as well.Let's call some coloring suitable if it is beautiful and there is no rectangle of the single color, consisting of at least $$$k$$$ tiles.Your task is to count the number of suitable colorings of the board of the given size.Since the answer can be very large, print it modulo $$$998244353$$$.

A single line contains two integers $$$n$$$ and $$$k$$$ ($$$1 \le n \le 500$$$, $$$1 \le k \le n^2$$$) — the number of rows and columns of the board and the maximum number of tiles inside the rectangle of the single color, respectively.

Print a single integer — the number of suitable colorings of the board of the given size modulo $$$998244353$$$.

NoteBoard of size $$$1 \times 1$$$ is either a single black tile or a single white tile. Both of them include a rectangle of a single color, consisting of $$$1$$$ tile.Here are the beautiful colorings of a board of size $$$2 \times 2$$$ that don't include rectangles of a single color, consisting of at least $$$3$$$ tiles:  The rest of beautiful colorings of a board of size $$$2 \times 2$$$ are the following:

// package training;

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

public class Sol {

    static int mod = 998244353;
    static int dp[][];
    static int dp2[][][];
    static int[] ans;
    public static void main(String[] args) throws Throwable {
        MyScanner sc = new MyScanner();
        PrintWriter pw = new PrintWriter(System.out);

        n = sc.nextInt();
        k = sc.nextInt();
        int [] ans2 = new int[n+1];

        ans = new int[n+1];
        for (int max = 1; max <= n; max++) {
            dp = new int[n][max+1];
            for (int i = 0; i < n; i++)
                Arrays.fill(dp[i], -1);
            ans2[max] = solve(1, 1, max);
        }

        for (int max = 1; max <= n; max++) {
            dp2 = new int[2][n][max+1];
            for (int i = 0; i < dp2.length; i++)
                for (int j = 0; j < dp2[i].length; j++) {
                    Arrays.fill(dp2[i][j], -1);
                }
            ans[max] = solve2(0, 0, 0, max);
        }

        int res = 0;
        for (int i = 1; i < ans.length; i++) {
            int rem = Math.min(n, (k-1)/i);
            res = add(res, (int)((1l*ans[i]*ans2[rem])%mod));
        }

        pw.println(res);

        pw.flush();
        pw.close();
    }

    static int n;
    static int k;
    static int solve(int idx, int consec, int max){
        if(idx == n)
            return 1;
        if(dp[idx][consec] != -1)
            return dp[idx][consec];
        if(consec == max)
            return dp[idx][consec] = solve(idx+1, 1, max);
        return dp[idx][consec] = add(solve(idx+1, 1, max), solve(idx+1, consec+1, max));
    }

    static int solve2(int idx, int consec, int done, int max){
        if(consec == max)
            done = 1;
        if(idx == n)
            return done;
        if(dp2[done][idx][consec] != -1)
            return dp2[done][idx][consec];
        if(consec == max)
            return dp2[done][idx][consec] = solve2(idx+1, 1, done, max);
        return dp2[done][idx][consec] = add(solve2(idx+1, 1, done, max), solve2(idx+1, consec+1, done, max));
    }

    static int add(int a, int b){
        int res = a+b;
        if(res >= mod)
            res -= mod;
        return res;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

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

public class Sol {

    static int mod = 998244353;
    static int dp[][];
    static int dp2[][][];
    static int[] ans;
    public static void main(String[] args) throws Throwable {
        MyScanner sc = new MyScanner();
        PrintWriter pw = new PrintWriter(System.out);

        n = sc.nextInt();
        k = sc.nextInt();
        int [] ans2 = new int[n+1];

        ans = new int[n+1];
        for (int max = 1; max <= n; max++) {
            dp = new int[n][max+1];
            for (int i = 0; i < n; i++)
                Arrays.fill(dp[i], -1);
            ans2[max] = solve(1, 1, max);
        }

        for (int max = 1; max <= n; max++) {
            dp2 = new int[2][n][max+1];
            for (int i = 0; i < dp2.length; i++)
                for (int j = 0; j < dp2[i].length; j++) {
                    Arrays.fill(dp2[i][j], -1);
                }
            ans[max] = solve2(0, 0, 0, max);
        }

        long res = 0;
        for (int i = 1; i < ans.length; i++) {
            int rem = Math.min(n, (k-1)/i);
            res = (res + (1l*ans[i]*ans2[rem])%mod)%mod;
        }

        pw.println(res);

        pw.flush();
        pw.close();
    }

    static int add(int a, int b){
        int ans = a+b;
        if(ans >= mod)
            ans -= mod;
        return ans;
    }

    static int n;
    static int k;
    static int solve(int idx, int consec, int max){
        if(idx == n)
            return 1;
        if(dp[idx][consec] != -1)
            return dp[idx][consec];
        if(consec == max)
            return dp[idx][consec] = solve(idx+1, 1, max);
        return dp[idx][consec] = add(solve(idx+1, 1, max), solve(idx+1, consec+1, max));
    }

    static int solve2(int idx, int consec, int done, int max){
        if(consec == max)
            done = 1;
        if(idx == n)
            return done;
        if(dp2[done][idx][consec] != -1)
            return dp2[done][idx][consec];
        if(consec == max)
            return dp2[done][idx][consec] = solve2(idx+1, 1, done, max);
        return dp2[done][idx][consec] = add(solve2(idx+1, 1, done, max), solve2(idx+1, consec+1, done, max));
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

// package training;

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

public class Sol {

    static int mod = 998244353;
    static int dp[][];
    static int[] ans;
    public static void main(String[] args) throws Throwable {
        MyScanner sc = new MyScanner();
        PrintWriter pw = new PrintWriter(System.out);

        n = sc.nextInt();
        k = sc.nextInt();
        int [] ans2 = new int[n+1];

        ans = new int[n+1];
        for (int max = 1; max <= n; max++) {
            dp = new int[n][max+1];
            for (int i = 0; i < n; i++)
                Arrays.fill(dp[i], -1);
            ans2[max] = solve(1, 1, max);
        }

        long res = 0;
        for (int i = 1; i < ans.length; i++) {
            int rem = Math.min(n, (k-1)/i);
            res = (res + (1l*(ans2[i]-ans2[i-1])*ans2[rem])%mod)%mod;
        }

        pw.println(res*2 % mod);

        pw.flush();
        pw.close();
    }

    static int add(int a, int b){
        int ans = a+b;
        if(ans >= mod)
            ans -= mod;
        return ans;
    }

    static int n;
    static int k;
    static int solve(int idx, int consec, int max){
        if(idx == n)
            return 1;
        if(dp[idx][consec] != -1)
            return dp[idx][consec];
        if(consec == max)
            return dp[idx][consec] = solve(idx+1, 1, max);
        return dp[idx][consec] = add(solve(idx+1, 1, max), solve(idx+1, consec+1, max));
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.List;
 import java.util.*;
 public class realfast implements Runnable
  {
    private static final int INF = (int) 1e9;
    long in= (long)Math.pow(10,9)+7;
    long fac[]= new long[3000];
    public  void solve() throws IOException
    {
        long m =  998244353;
        int n  = readInt();
        int k = readInt();
        long sum[]= new long[n+1];
        sum[0]=0;
        for(int i=1;i<=n;i++)
        {
            long dp[]= new long[n+2];
            dp[n+1]=1;
            for(int j=n;j>=1;j--)
            {
                for(int l=1;l<=Math.min(i,n-j+1);l++)
                {
                    dp[j]= (dp[j]%m+ dp[j+l]%m)%m;
                }
            }
            sum[i]= (dp[1])%m;
        }
        long val =0;

        //out.println();
        for(int i=1;i<=n;i++)
        {

            int j = k/i;
            if(k%i==0)
                j--;
            j=Math.min(n,j);
            val = (val%m + (((sum[i]%m-sum[i-1]%m+m)%m)*(sum[j]%m))%m)%m;
        }
        val = (val*2)%m;
        out.println(val);

    }
    public int seg(int seg[], int left, int right, int index, int val)
    {
        if(left==right)
        {
            seg[index]=1;
            return 1;
        }
        int mid = left+(right-left)/2;

        if(val<=mid)
        {
            seg(seg,left,mid,2*index+1,val);
        }
        else
        {
            seg(seg,mid+1,right,2*index+2,val);
        }
        seg[index]= seg[2*index+1]+seg[2*index+2];
        return seg[index];
    }
    public int val(int seg[], int left , int right, int l , int r,int index)
    {
            if(left>r||right<l)
            {
               return 0;
            }
            int mid = left+(right-left)/2;
            if(left>=l&&right<=r)
            return seg[index];

            return val(seg,left,mid,l,r,2*index+1)+val(seg,mid+1,right,l,r,2*index+2);
    }
    public int gcd(int a , int b )
    {
      if(a<b)
      {
        int t =a;
        a=b;
        b=t;
      }
      if(a%b==0)
        return b ;
      return gcd(b,a%b);
    }
    public long pow(long n , long p,long m)
    {
         if(p==0)
            return 1;
        long val = pow(n,p/2,m);;
        val= (val*val)%m;
        if(p%2==0)
            return val;
        else
            return (val*n)%m;
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public static void main(String[] args) {
        new Thread(null, new realfast(), "", 128 * (1L << 20)).start();
    }

    private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    private BufferedReader reader;
    private StringTokenizer tokenizer;
    private PrintWriter out;

    @Override
    public void run() {
        try {
            if (ONLINE_JUDGE || !new File("input.txt").exists()) {
                reader = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                reader = new BufferedReader(new FileReader("input.txt"));
                out = new PrintWriter("output.txt");
            }
            solve();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                reader.close();
            } catch (IOException e) {
                // nothing
            }
            out.close();
        }
    }

    private String readString() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    @SuppressWarnings("unused")
    private int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    @SuppressWarnings("unused")
    private long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    @SuppressWarnings("unused")
    private double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }
}
class edge implements Comparable<edge>{
    int val ;
    int color;

    edge(int u, int v)
    {
       this.val=u;
       this.color=v;
    }
    public int compareTo(edge e)
    {
        return this.val-e.val;
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.Reader;
import java.io.InputStreamReader;
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;
        MyInput in = new MyInput(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskE {
        static final int mod = 998244353;

        public void solve(int testNumber, MyInput in, PrintWriter out) {
            int n = in.nextInt();
            int K = in.nextInt();

            long[][] dp = new long[n + 1][n + 1];
            for (int i = 1; i <= n; i++) {
                dp[i][0] = 1;
                for (int j = 1; j <= n; j++) {
                    for (int k = 1; k <= i && k <= j; k++) {
                        dp[i][j] += dp[i][j - k];
                        if (dp[i][j] >= mod) dp[i][j] -= mod;
                    }
                }
            }

            long ans = 0;
            long[][] dp2 = new long[n + 1][n + 1];
            for (int i = 1; i <= n; i++)
                if (i < K) {
                    for (long[] d : dp2) Arrays.fill(d, 0L);
                    dp2[0][0] = ((dp[i][n] - dp[i - 1][n]) * 2 % mod + mod) % mod;
                    for (int j = 1; j <= n; j++) {
                        for (int k = 1; k <= j; k++) {
                            if (k * i < K) {
                                dp2[j][k] += dp2[j - 1][k - 1];
                                if (dp2[j][k] >= mod) dp2[j][k] -= mod;
                            }
                            if (j > 1) {
                                dp2[j][1] += dp2[j - 1][k - 1];
                                if (dp2[j][1] >= mod) dp2[j][1] -= mod;
                            }
                        }
                    }
//            dump(i, dp2);
                    for (int k = 1; k <= n; k++) {
                        ans += dp2[n][k];
                    }
                }

            out.println((ans % mod + mod) % mod);
        }

    }

    static class MyInput {
        private final BufferedReader in;
        private static int pos;
        private static int readLen;
        private static final char[] buffer = new char[1024 * 8];
        private static char[] str = new char[500 * 8 * 2];
        private static boolean[] isDigit = new boolean[256];
        private static boolean[] isSpace = new boolean[256];
        private static boolean[] isLineSep = new boolean[256];

        static {
            for (int i = 0; i < 10; i++) {
                isDigit['0' + i] = true;
            }
            isDigit['-'] = true;
            isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
            isLineSep['\r'] = isLineSep['\n'] = true;
        }

        public MyInput(InputStream is) {
            in = new BufferedReader(new InputStreamReader(is));
        }

        public int read() {
            if (pos >= readLen) {
                pos = 0;
                try {
                    readLen = in.read(buffer);
                } catch (IOException e) {
                    throw new RuntimeException();
                }
                if (readLen <= 0) {
                    throw new MyInput.EndOfFileRuntimeException();
                }
            }
            return buffer[pos++];
        }

        public int nextInt() {
            int len = 0;
            str[len++] = nextChar();
            len = reads(len, isSpace);
            int i = 0;
            int ret = 0;
            if (str[0] == '-') {
                i = 1;
            }
            for (; i < len; i++) ret = ret * 10 + str[i] - '0';
            if (str[0] == '-') {
                ret = -ret;
            }
            return ret;
        }

        public char nextChar() {
            while (true) {
                final int c = read();
                if (!isSpace[c]) {
                    return (char) c;
                }
            }
        }

        int reads(int len, boolean[] accept) {
            try {
                while (true) {
                    final int c = read();
                    if (accept[c]) {
                        break;
                    }
                    if (str.length == len) {
                        char[] rep = new char[str.length * 3 / 2];
                        System.arraycopy(str, 0, rep, 0, str.length);
                        str = rep;
                    }
                    str[len++] = (char) c;
                }
            } catch (MyInput.EndOfFileRuntimeException e) {
            }
            return len;
        }

        static class EndOfFileRuntimeException extends RuntimeException {
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

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

    static class EInverseColoring {
        final long MOD = 998244353;

        private void getSumTill(long[] ar, long[] res) {
            long tillNow = 0;
            for (int i = 0; i < ar.length; i++) {
                tillNow += ar[i];
                if (tillNow >= MOD) {
                    tillNow -= MOD;
                }
                res[i] = tillNow;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.NextInt();
            int k = in.NextInt();
            long res = 0;
            long[][] exact = new long[n + 1][n + 1];
            exact[0][0] = 1;
            long[][] lessOrEqualTo = new long[n + 1][n + 1];
            getSumTill(exact[0], lessOrEqualTo[0]);
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= i; j++) {
                    exact[i][j] += lessOrEqualTo[i - j][j];
                    if (exact[i][j] >= MOD)
                        exact[i][j] -= MOD;
                    for (int l = j + 1; l <= i - j; l++) {
                        exact[i][l] += exact[i - j][l];
                        if (exact[i][l] >= MOD)
                            exact[i][l] -= MOD;
                    }
                }
                getSumTill(exact[i], lessOrEqualTo[i]);
            }

            for (int i = 1; i <= n; i++) {
                int j = k / i;
                while (i * j < k) j++;
                if (j == 0) continue;
                j = Math.min(n + 1, j);
                // exactly i and less then j;
                res += exact[n][i] * lessOrEqualTo[n][j - 1] % MOD;
                res %= MOD;
            }
            out.println(res * 2 % MOD);
        }

    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

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

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine(), " \t\n\r\f,");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int NextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.flush();out.close();
    }
        static class TaskE {
        final int mod=998244353;
        long add(long a,long b){
        	a+=b;
        	if(a>=mod)a-=mod;
        	return a;
        }
        long mul(long a,long b){
        	a*=b;
        	if(a>=mod)a%=mod;
        	return a;
        }

	 	  public void solve(int testNumber, InputReader in, PrintWriter out) {
	 	  	int n=in.nextInt(),k=in.nextInt();
 			long dp[][][][]=new long[2][n+1][n+1][2];
 			dp[1][1][1][1]=1;dp[1][1][0][0]=1;
 			int t=1;
 			for(int d1=2;d1<=n;d1++){
 				t=1-t;
 				for(int d2=1;d2<=d1;d2++){
 					for(int d3=1;d3<=d2;d3++){
 						for(int d4=0;d4<=1;d4++){
 							dp[t][d2][d3][d4]=add((d3==d2?dp[1-t][d2-1][d3-1][d4]:0),dp[1-t][d2][d3-1][d4]);
 						}
 					}
 					dp[t][d2][0][0]=dp[t][d2][0][1]=0;
 					for(int d3=1;d3<=d2;d3++){
 						for(int d4=0;d4<=1;d4++){
 							dp[t][d2][0][d4]=add(dp[t][d2][d3][1-d4],dp[t][d2][0][d4]);
 						}
 					}
 				}
 			}
 			long val[]=new long[n+1];
 			for(int d1=1;d1<=n;d1++){
 				for(int d2=1;d2<=d1;d2++){
 					val[d1]=add(val[d1],add(dp[t][d1][d2][0],dp[t][d1][d2][1]));
 				}
 			}
 			long ans=0;
 			for(int i=1;i<=n;i++){
 				for(int j=1;j<=n;j++){
 					if(i*j>=k)continue;
 					ans=add(ans,mul(val[i],val[j]));
 				}
 			}
 			ans=mul(ans,2);
 			out.print(ans);
          }
//         pair ja[][];long w[];int from[],to[],c[];
//             void make(int n,int m,InputReader in){
//              ja=new pair[n+1][];w=new long[m];from=new int[m];to=new int[m];c=new int[n+1];
//              for(int i=0;i<m;i++){
//               int u=in.nextInt(),v=in.nextInt();long wt=in.nextLong();
//               c[u]++;c[v]++;from[i]=u;to[i]=v;w[i]=wt;
//              }
//              for(int i=1;i<=n;i++){
//               ja[i]=new pair[c[i]];c[i]=0;
//              }
//              for(int i=0;i<m;i++){
//               ja[from[i]][c[from[i]]++]=new pair(to[i],w[i]);
//               ja[to[i]][c[to[i]]++]=new pair(from[i],w[i]);
//              }
//             }
//        int[] radixSort(int[] f){ return radixSort(f, f.length); }
//	int[] radixSort(int[] f, int n)
//	{
//		int[] to = new int[n];
//		{
//			int[] b = new int[65537];
//			for(int i = 0;i < n;i++)b[1+(f[i]&0xffff)]++;
//			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
//			for(int i = 0;i < n;i++)to[b[f[i]&0xffff]++] = f[i];
//			int[] d = f; f = to;to = d;
//		}
//		{
//			int[] b = new int[65537];
//			for(int i = 0;i < n;i++)b[1+(f[i]>>>16)]++;
//			for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
//			for(int i = 0;i < n;i++)to[b[f[i]>>>16]++] = f[i];
//			int[] d = f; f = to;to = d;
//		}
//		return f;
//	}
    }
    static class InputReader {
        BufferedReader br;
        StringTokenizer st;
        public InputReader(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
            st = null;
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

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

public class CF1027E {
	static final int MD = 998244353;
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n_ = Integer.parseInt(st.nextToken());
		int k_ = Integer.parseInt(st.nextToken());
		long[][] dp = new long[1 + n_][1 + n_];	// exactly k
		long[][] dq = new long[1 + n_][1 + n_];	// at most k
		dp[0][0] = 1;
		for (int k = 0; k <= n_; k++)
			dq[0][k] = 1;
		for (int n = 1; n <= n_; n++)
			for (int k = 1; k <= n_; k++) {
				long x = 0;
				for (int i = 0; i + k <= n; i++)
					x = (x + dq[i][k - 1] * dq[n - i - k][k]) % MD;
				dp[n][k] = x;
				dq[n][k] = (dq[n][k - 1] + dp[n][k]) % MD;
			}
		long ans = 0;
		for (int a = 1; a <= n_; a++)
			for (int b = 1; b <= n_ && a * b < k_; b++)
				ans = (ans + dp[n_][a] * dp[n_][b]) % MD;
		ans = ans * 2 % MD;
		System.out.println(ans);
	}
}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;

public class E2 {

	static int N;
	static int K;
	static int mod = 998244353;
	static long modInvOf2;
	static int dp[][][][];
	static int up[][][][];
	static int pow2[];
	static int iter = -1;
	public static void main(String[] args) {
		JS in = new JS();
		N = in.nextInt();
		K = in.nextInt();
		modInvOf2 = modInv(2, mod);
		dp = new int[2][2][N+1][N+1];
		up = new int[2][2][N+1][N+1];
		long regular[] = new long[N+1];
		pow2 = new int[600];
		pow2[0] = 1;
		for(int i = 1; i < 600; i++) {
			pow2[i] = pow2[i-1]*2;
			if(pow2[i] >= mod) pow2[i] -= mod;
		}

		for(int run = 1; run <= N; run++) {
			iter = run;
			regular[run] = go(1, run==1?1:0, 1, 1, run) + go(0, run==1?1:0, 1, 1, run);
			if(regular[run] >= mod) regular[run] -= mod;
		}
		long other[] = new long[N+1];
		for(int i = 1; i <= N; i++) {
			for(int j = 1; j <= i; j++) {
				other[i] += regular[j];
				if(other[i] >= mod) other[i] -= mod;
			}
		}

		long res = 0;
		for(int run = 1; run <= N; run++) {
			long max = K/run;
			if(K%run == 0) max--;
			if(max == 0) continue;
			res += (regular[run]*other[Math.min(N,(int)max)])%mod;
			if(res >= mod) res -= mod;
		}
		res = ((res*modInvOf2)%mod+mod)%mod;
		System.out.println(res);

	}
	static int go(int bit, int have, int index, int cur, int goal) {
		if(index >= N) return have;
		if(cur + (N-index) < goal) return have*pow2[N-index];
		if(up[bit][have][index][cur] == iter) return dp[bit][have][index][cur];
//		//take
		int take = -1;
		if(bit == 0) {
			take = go(1, have, index+1, 1, goal);
		}
		else {
			if(cur+1 > goal) take = 0;
			else take = go(1, have | (cur+1 == goal ? 1 : 0), index+1, cur+1, goal);
		}
		//leave
		int leave = -1;
		if(bit == 1) {
			leave = go(0, have, index+1, 1, goal);
		}
		else {
			if(cur+1 > goal) leave = 0;
			else leave = go(0, have | (cur+1 == goal? 1 : 0), index+1, cur+1, goal);
		}
		int res = take+leave;
		if(res >= mod) res -= mod;
		up[bit][have][index][cur] = iter;
		return dp[bit][have][index][cur] = res;
	}

	static long modInv(long x, long mod) {
		if(x == 1) return 1;
		long r = mod % x;
		return modInv(r, x % r, 0, 1, mod / x, x / r);
	}
	static long modInv(long a, long b, long y0, long y1, long q0, long q1) {
		long y2 = y0 - y1*q0;
		return b == 0 ? y2 : modInv(b, a % b, y1, y2, q1, a / b);
	}

	static class JS{
		public int BS = 1<<16;
		public char NC = (char)0;
		byte[] buf = new byte[BS];
		int bId = 0, size = 0;
		char c = NC;
		double num = 1;
		BufferedInputStream in;

		public JS() {
			in = new BufferedInputStream(System.in, BS);
		}

		public JS(String s) throws FileNotFoundException {
			in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
		}

		public char nextChar(){
			while(bId==size) {
				try {
					size = in.read(buf);
				}catch(Exception e) {
					return NC;
				}
				if(size==-1)return NC;
				bId=0;
			}
			return (char)buf[bId++];
		}

		public int nextInt() {
			return (int)nextLong();
		}

		public long nextLong() {
			num=1;
			boolean neg = false;
			if(c==NC)c=nextChar();
			for(;(c<'0' || c>'9'); c = nextChar()) {
				if(c=='-')neg=true;
			}
			long res = 0;
			for(; c>='0' && c <='9'; c=nextChar()) {
				res = (res<<3)+(res<<1)+c-'0';
				num*=10;
			}
			return neg?-res:res;
		}

		public double nextDouble() {
		    while(c!='.'&&c!='-'&&(c <'0' || c>'9')) c = nextChar();
		    boolean neg = c=='-';
		    if(neg)c=nextChar();
		    boolean fl = c=='.';
		    double cur = nextLong();
		    if(fl) return neg ? -cur/num : cur/num;
		    if(c == '.') {
			double next = nextLong();
			return neg ? -cur-next/num : cur+next/num;
		    }
		    else return neg ? -cur : cur;
		}

		public String next() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c>32) {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public String nextLine() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c!='\n') {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public boolean hasNext() {
			if(c>32)return true;
			while(true) {
				c=nextChar();
				if(c==NC)return false;
				else if(c>32)return true;
			}
		}
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
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;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        E solver = new E();
        solver.solve(1, in, out);
        out.close();
    }

    static class E {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.ni(), K = in.ni();
            long mod = 998244353;
            long[][] dp = new long[n + 1][n + 1];
            for (int lim = 1; lim <= n; lim++) {
                long sum = 1;
                dp[0][lim] = 1;
                for (int i = 1; i <= n; i++) {
                    dp[i][lim] = (dp[i][lim] + sum) % mod;
                    sum = (sum + dp[i][lim]) % mod;
                    if (i >= lim)
                        sum = (sum - dp[i - lim][lim] + mod) % mod;
                }
            }
            long ans = 0;
            for (int k = 1; k < Math.min(K, n + 1); k++) {
                long h = dp[n][k] - dp[n][k - 1];
                int lim = K / k;
                if (K % k == 0)
                    lim--;
                if (lim > n)
                    lim = n;
                ans += dp[n][lim] * h % mod;
            }
            out.println(2 * ans % mod);
        }

    }

    static class FastScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

        public String ns() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String rl = in.readLine();
                    if (rl == null) {
                        return null;
                    }
                    st = new StringTokenizer(rl);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        public int ni() {
            return Integer.parseInt(ns());
        }

    }
}

import java.util.Scanner;

public class E {

	private static long MOD = 998244353;

	private static long[][] cache;
	private static long dp(int n, int x, int idx, int used) {
		// impossible
		if (used == 0 && idx + x > n) {
			return 0;
		}
		// base case
		if (idx == n) {
			return used;
		}
		// seen before
		if (cache[idx][used] > -1) {
			return cache[idx][used];
		}
		// recursive case
		long ans = 0;
		for (int diff = 1; diff <= x && idx + diff <= n; ++diff) {
			int nextUsed = used;
			if (diff == x)
				nextUsed = 1;
			ans += dp(n, x, idx + diff, nextUsed);
			ans %= MOD;
		}
		return cache[idx][used] = ans;
	}

	private static long[] cacheF;
	private static long f(int n, int x) {
		if (x <= 0 || x > n)
			return 0;
		if (cacheF[x] != -1)
			return cacheF[x];
		cache = new long[n][2];
		for (int i = 0; i < cache.length; ++i)
			for (int j = 0; j < cache[i].length; ++j)
				cache[i][j] = -1;
		return cacheF[x] = dp(n, x, 0, 0);
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt() - 1;
		cacheF = new long[n + 1];
		for (int i = 0; i < cacheF.length; ++i)
			cacheF[i] = -1L;
		long ans = 0;
		for (int i = 1; i <= k && i <= n; ++i) {
			for (int j = 1; j <= k/i; ++j) {
				ans += 2*f(n, i)*f(n, j);
				ans %= MOD;
			}
		}
		System.out.println(ans);
	}

}

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

public class Main
{
	public static void main(String[] args)
	{
		FastReader reader = new FastReader();
		PrintWriter writer = new PrintWriter(System.out);

		int n = reader.nextInt();
		int k = reader.nextInt();
		long[][] dp = new long[n+1][n+1];
		long mod = 998244353;

		dp[0][1] =1;

		for (int i=1; i<=n; i++)
			for (int j=1; j<=i; j++)
			{
				for (int x=1; x<j; x++)
				{
					dp[i][j] += dp[i-x][j];
					dp[i][j] %= mod;
				}
				for (int x=1; x<=j; x++)
				{
					dp[i][j] += dp[i-j][x];
					dp[i][j] %= mod;
				}
			}

		long ans = 0;

		/*for (int i=0; i<=n; i++)
		{
			for (int j=0; j<=n; j++)
				writer.print(dp[i][j] + " ");
			writer.println();
		}*/

		for (int i=1; i<=n; i++)
			for (int j=1; j<=n; j++)
				if (i*j < k)
				{
					ans += (dp[n][i]*dp[n][j])%mod;
					ans += mod;
				}

		writer.print((ans*2)%mod);
		writer.close();
	}

	static class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

		public FastReader()
		{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next()
		{
			while (st == null || !st.hasMoreElements())
			{
				try
				{
					st = new StringTokenizer(br.readLine());
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
	}
}

//make sure to make new file!
import java.io.*;
import java.util.*;
//danny, O(N^2)
public class E1027b{

   public static long MOD = 998244353;

   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(System.out);

      StringTokenizer st = new StringTokenizer(f.readLine());

      int n = Integer.parseInt(st.nextToken());
      int m = Integer.parseInt(st.nextToken());

      if(m == 1){
         out.println("0");
         out.close();
         return;
      }

      long[] array = new long[n+1];            //number of ways such that max chunk is n
      array[0] = 0;
      array[1] = 1;

      for(int i = 2; i <= n; i++){
         long[] dp = new long[n+1];

         dp[0] = 1;

         long sum = 1L;
         for(int k = 1; k <= n; k++){
            dp[k] = sum;
            sum += dp[k];
            if(k >= i){
               sum -= dp[k-i];
            }

            sum = (sum + MOD)%MOD;
         }

         array[i] = dp[n];

      }

      //psums
      long[] psums = new long[n+2];

      psums[0] = 0L;

      for(int k = n+1; k >= 1; k--){
         psums[k] = array[k-1];
         if(k > 1) array[k-1]-=array[k-2];
      }

      long answer = 0L;

      for(int k = 1; k <= n; k++){
         if(k >= (int)m)
            continue;
         int i = m/k;
         if(k*i==m) i--;
         i = Math.min(i,n);
         long prod = (array[k]*psums[i+1]+MOD)%MOD;
         answer = (answer + prod + MOD)%MOD;
      }

      answer = (answer*2 + MOD)%MOD;
      out.println(answer);

      out.close();
   }
}

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

import javax.swing.plaf.synth.SynthSpinnerUI;

public class tr1 {
	static PrintWriter out;
	static StringBuilder sb;
	static int inf = (int) 1e9;
	static long mod = (long) 998244353;
	static int[] si;
	static ArrayList<Integer> primes;
	static HashSet<Integer> pr;
	static int n, k, m;
	static int[] in;
	static HashMap<Integer, Integer> factors;
	static HashSet<Integer> f;
	static int[] fac, a, b;
	static int[] l, r;
	static int[][] memo;
	static int[] numc;
	static ArrayList<Integer>[] ad;
	static HashMap<Integer, Integer> hm;
	static pair[] ed;
	static TreeSet<Integer>[] np;
	static TreeMap<pair, Integer> tm;
	static int[] le, re;
	static char[] h;
	static pair[] mm;
	static boolean[] vis;
	static int y;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		out = new PrintWriter(System.out);
		int n = sc.nextInt();
	    int k=sc.nextInt();
	    long [][][]dp=new long [3][n+1][n+1];
	    dp[1][1][1]=1l;
	    int l=0;
	    for(int i=1;i<n;i++) {
	    	int ik= i&1 ;
	    	int nk=0;
	    	if(ik==1)
	    		nk=2;
	    	else {
	    		nk=1;
	    		ik=2;
	    	}
	    	for(long []r:dp[nk])
	    		Arrays.fill(r, 0);
	    	for(int j=1;j<n;j++) {
	    		for(int o=1;o<=n;o++) {
	    			 dp[nk][j+1][Math.max(o, j+1)]=(dp[ik][j][o]+dp[nk][j+1][Math.max(o, j+1)]);
	    			 dp[nk][1][Math.max(o, 1)]=(dp[ik][j][o]+dp[nk][1][Math.max(o, 1)]);
	    			 if(dp[nk][j+1][Math.max(o, j+1)]>=mod)
	    				 dp[nk][j+1][Math.max(o, j+1)]-=mod;
	    			 if(dp[nk][1][Math.max(o, 1)]>=mod)
	    				 dp[nk][1][Math.max(o, 1)]-=mod;
	    		}
	    	}
	    }
	    if((n&1)==0)
	    	l=2;
	    else
	    	l=1;

	    long []co=new long[n+1];
	    for(int i=1;i<=n;i++)
	    	for(int j=1;j<=n;j++)
	    	 co[i]=(dp[l][j][i]+co[i])%mod;
	    long ans=0;
	    for(int i=1;i<=n;i++)
	    	for(int j=1;j<=n;j++)
	    		if(i*j<k)
	    		    ans=(ans+co[i]*co[j])%mod;
	    out.print((ans<<1)%mod);
		out.flush();
	}

	static class pair implements Comparable<pair> {
		int x;
		int y;
		int z;
		char d;

		pair(int f, int t, int u, char r) {
			x = f;
			y = t;
			z = u;
			d = r;
		}

		public String toString() {
			return x + " " + y + " " + z + " " + d;
		}

		@Override
		public int compareTo(pair o) {
			return z - o.z;
		}
	}

	static class pair1 implements Comparable<pair1> {
		int x;
		int y;
		int z;

		pair1(int f, int t, int u) {
			x = f;
			y = t;
			z = u;
			// num = n;
		}

		public String toString() {
			return x + " " + y;
		}

		@Override
		public int compareTo(pair1 o) {
			if (x == o.x)
				return y - o.y;
			return x - o.x;
		}
	}

	static public class FenwickTree { // one-based DS

		int n;
		int[] ft;

		FenwickTree(int size) {
			n = size;
			ft = new int[n + 1];
			// for(int i=1;i<=n;i++)
			// ft[i]=i;
		}

		int rsq(int b) // O(log n)
		{
			int sum = 0;
			while (b > 0) {
				sum += ft[b];
				b -= b & -b;
			} // min?
			return sum;
		}

		int rsq(int a, int b) {
			return rsq(b) - rsq(a - 1);
		}

		void point_update(int k, int val) // O(log n), update = increment
		{
			while (k <= n) {
				// System.out.println(k+" "+val);
				ft[k] += val;
				k += k & -k;
			} // min?
		}

		int point_query(int idx) // c * O(log n), c < 1
		{
			int sum = ft[idx];
			if (idx > 0) {
				int z = idx ^ (idx & -idx);
				--idx;
				while (idx != z) {
					// System.out.println("oo");
					sum -= ft[idx];
					idx ^= idx & -idx;
				}
			}
			return sum;
		}

		void scale(int c) {
			for (int i = 1; i <= n; ++i)
				ft[i] *= c;
		}

		int findIndex(int cumFreq) {
			int msk = n;
			while ((msk & (msk - 1)) != 0)
				msk ^= msk & -msk; // msk will contain the MSB of n

			int idx = 0;
			while (msk != 0) {
				int tIdx = idx + msk;
				if (tIdx <= n && cumFreq >= ft[tIdx]) {
					idx = tIdx;
					cumFreq -= ft[tIdx];
				}
				msk >>= 1;
			}
			if (cumFreq != 0)
				return -1;
			return idx;
		}
	}

	static public class SegmentTree { // 1-based DS, OOP

		int N; // the number of elements in the array as a power of 2 (i.e. after padding)
		long[] array, sTree, lazy;

		SegmentTree(long[] in) {
			array = in;
			N = in.length - 1;
			sTree = new long[N << 1]; // no. of nodes = 2*N - 1, we add one to cross out index zero
			lazy = new long[N << 1];
			build(1, 1, N);
		}

		void build(int node, int b, int e) // O(n)
		{
			if (b == e)
				sTree[node] = array[b];
			else {
				int mid = b + e >> 1;
				build(node << 1, b, mid);
				build(node << 1 | 1, mid + 1, e);
				sTree[node] = sTree[node << 1] + sTree[node << 1 | 1];
			}
		}

		void update_point(int index, int val) // O(log n)
		{
			index += N - 1;
			sTree[index] += val;
			while (index > 1) {
				index >>= 1;
				sTree[index] = sTree[index << 1] + sTree[index << 1 | 1];
			}
		}

		void update_range(int i, int j, long val) // O(log n)
		{
			update_range(1, 1, N, i, j, val);
		}

		void update_range(int node, int b, int e, int i, int j, long val) {
			if (i > e || j < b)
				return;
			if (b >= i && e <= j) {
				sTree[node] += (e - b + 1) * val;
				lazy[node] += val;
			} else {
				int mid = b + e >> 1;
				propagate(node, b, mid, e);
				update_range(node << 1, b, mid, i, j, val);
				update_range(node << 1 | 1, mid + 1, e, i, j, val);
				sTree[node] = sTree[node << 1] + sTree[node << 1 | 1];
			}

		}

		void propagate(int node, int b, int mid, int e) {
			lazy[node << 1] += lazy[node];
			lazy[node << 1 | 1] += lazy[node];
			sTree[node << 1] += (mid - b + 1) * lazy[node];
			sTree[node << 1 | 1] += (e - mid) * lazy[node];
			lazy[node] = 0;
		}

		long query(int i, int j) {
			return query(1, 1, N, i, j);
		}

		long query(int node, int b, int e, int i, int j) // O(log n)
		{
			if (i > e || j < b)
				return 0;
			if (b >= i && e <= j)
				return sTree[node];
			int mid = b + e >> 1;
			propagate(node, b, mid, e);
			long q1 = query(node << 1, b, mid, i, j);
			long q2 = query(node << 1 | 1, mid + 1, e, i, j);
			return q1 + q2;

		}

	}

	static long gcd(long a, long b) {

		if (b == 0) {
			return a;
		}
		return gcd(b, a % b);
	}

	public int[] merge(int[] d, int st, int e) {
		if (st > e)
			return null;
		if (e == st) {
			int[] ans = { d[e] };
			return ans;
		}
		int mid = (st + e) / 2;
		int[] ans = new int[e - st + 1];
		int[] ll = merge(d, st, mid);
		int[] rr = merge(d, mid + 1, e);
		if (ll == null)
			return rr;
		if (rr == null)
			return ll;
		int iver = 0;
		int idxl = 0;
		int idxr = 0;
		for (int i = st; i <= e; i++) {
			if (ll[idxl] < rr[idxr]) {

			}
		}
		return ans;
	}

	public static class pair2 implements Comparable<pair2> {
		int a;
		int idx;

		pair2(int a, int i) {
			this.a = a;
			idx = i;
		}

		public String toString() {
			return a + " " + idx;
		}

		@Override
		public int compareTo(pair2 o) {
			// TODO Auto-generated method stub
			return idx - o.idx;
		}
	}

	static long inver(long x) {
		int a = (int) x;
		long e = (mod - 2);
		long res = 1;
		while (e > 0) {
			if ((e & 1) == 1) {
				// System.out.println(res*a);
				res = (int) ((1l * res * a) % mod);
			}
			a = (int) ((1l * a * a) % mod);
			e >>= 1;
		}
		// out.println(res+" "+x);
		return res % mod;
	}

	static int atMostSum(int arr[], int n, int k) {
		int sum = 0;
		int cnt = 0, maxcnt = 0;

		for (int i = 0; i < n; i++) {

			// If adding current element doesn't
			// cross limit add it to current window
			if ((sum + arr[i]) <= k) {
				sum += arr[i];
				cnt++;
			}

			// Else, remove first element of current
			// window and add the current element
			else if (sum != 0) {
				sum = sum - arr[i - cnt] + arr[i];
			}

			// keep track of max length.
			maxcnt = Math.max(cnt, maxcnt);
		}
		return maxcnt;
	}

	public static int[] longestSubarray(int[] inp) {
		// array containing prefix sums up to a certain index i
		int[] p = new int[inp.length];
		p[0] = inp[0];
		for (int i = 1; i < inp.length; i++) {
			p[i] = p[i - 1] + inp[i];
		}

		// array Q from the description below
		int[] q = new int[inp.length];
		q[inp.length - 1] = p[inp.length - 1];
		for (int i = inp.length - 2; i >= 0; i--) {
			q[i] = Math.max(q[i + 1], p[i]);
		}
		int a = 0;
		int b = 0;
		int maxLen = 0;
		int curr;
		int[] res = new int[] { -1, -1 };
		while (b < inp.length) {
			curr = a > 0 ? q[b] - p[a - 1] : q[b];
			if (curr >= 0) {
				if (b - a > maxLen) {
					maxLen = b - a;
					res = new int[] { a, b };
				}
				b++;
			} else {
				a++;
			}
		}
		return res;
	}

	static void factor(int n) {
		if (si[n] == n) {
			f.add(n);
			return;
		}
		f.add(si[n]);
		factor(n / si[n]);
	}

	static void seive() {
		si = new int[100001];
		primes = new ArrayList<>();
		int N = 100001;
		si[1] = 1;
		for (int i = 2; i < N; i++) {
			if (si[i] == 0) {
				si[i] = i;
				primes.add(i);
			}
			for (int j = 0; j < primes.size() && primes.get(j) <= si[i] && (i * primes.get(j)) < N; j++)
				si[primes.get(j) * i] = primes.get(j);

		}
	}

	static class unionfind {
		int[] p;
		int[] size;
		int jum;

		unionfind(int n) {
			p = new int[n];
			size = new int[n];

			for (int i = 0; i < n; i++) {
				p[i] = i;
			}
			jum = n;
			Arrays.fill(size, 1);
		}

		int findSet(int v) {
			if (v == p[v])
				return v;
			return p[v] = findSet(p[v]);
		}

		boolean sameSet(int a, int b) {
			a = findSet(a);
			b = findSet(b);
			if (a == b)
				return true;
			return false;
		}

		int max() {
			int max = 0;
			for (int i = 0; i < size.length; i++)
				if (size[i] > max)
					max = size[i];
			return max;
		}

		void combine(int a, int b) {
			a = findSet(a);
			b = findSet(b);
			if (a == b)
				return;
			jum--;
			if (size[a] > size[b]) {
				p[b] = a;
				size[a] += size[b];

			} else {
				p[a] = b;
				size[b] += size[a];
			}
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}

import java.io.BufferedReader;
// import java.io.FileInputStream;
// import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.round;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverse;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;
import static java.util.Comparator.comparing;
import static java.util.Comparator.comparingInt;
import static java.util.Comparator.comparingLong;

public class Main {
    FastScanner in;
    PrintWriter out;

    long mod = 998244353;

    private void solve() throws IOException {
        int n = in.nextInt(), k = in.nextInt() - 1, m = min(n, k);
        long[] cntLine = new long[m + 1];
        long[] cnt = new long[m];

        long sum, min;
        for (int curK = 1; curK <= m; curK++) {
            fill(cnt, 0);
            cnt[0] = 1;
            sum = 1;

            for (int curN = 2, pos = curK - 1; curN <= n; curN++, pos = (pos + curK - 1) % curK) {
                min = cnt[pos];
                cnt[pos] = sum;
                sum = (sum + sum + mod - min) % mod;
            }

            for (int i = 0; i < m; i++)
                cntLine[curK] = (cntLine[curK] + cnt[i]) % mod;
        }

        for (int i = m; i > 0; i--)
            cntLine[i] = (cntLine[i] + mod - cntLine[i - 1]) % mod;

        long ans = 0;
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= m; j++)
                if (i * j <= k)
                    ans = (ans + cntLine[i] * cntLine[j] % mod) % mod;
        out.println((ans * 2) % mod);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

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

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}

//package com.company;

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

public class Main {
    static long TIME_START, TIME_END;
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        //        Scanner sc = new Scanner(new FileInputStream("Test.in"));
        PrintWriter pw = new PrintWriter(System.out);
        //        PrintWriter pw = new PrintWriter(new FileOutputStream("Test.out"));
        //        PrintWriter pw = new PrintWriter(new FileOutputStream("Test.in"));

        Runtime runtime = Runtime.getRuntime();
        long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
        TIME_START = System.currentTimeMillis();
        Task t = new Task();
        t.solve(sc, pw);
        TIME_END = System.currentTimeMillis();
        long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
        pw.close();
        System.out.println("Memory increased:" + (usedMemoryAfter-usedMemoryBefore) / 1000000 );
        System.out.println("Time used: " + (TIME_END - TIME_START) + ".");
    }

    public static class Task {

        public long[][] dp;
        public long[][] subdp;
        public long[] sef;

        public long power(long a, int b) {
            if (b == 0) return 1;
            if (b % 2 == 0) return power(a * a % mod, b >> 1);
            return a * power(a * a % mod, b >> 1) % mod;
        }

        public void calc(int n) {
            dp = new long[n + 1][n + 1];
            subdp = new long[n + 1][n + 1];
            sef = new long[n + 1];
            long t = 1;
            for (int i = 0; i < n + 1; i++) {
                sef[i] = t;
                t *= 2; t %= mod;
            }
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    search(i, j);
                }
            }
            subdp[n][1] = dp[n][1];
            for (int i = 1; i < n; i++) {
                subdp[n][i + 1] = dp[n][i + 1] - dp[n][i] + mod;
                if (subdp[n][i + 1] >= mod) {
                    subdp[n][i + 1] -= mod;
                }
            }
        }

        public long search(int n, int k) {
            if (dp[n][k] != 0) {
                return dp[n][k];
            }
            if (k >= n) {
                return dp[n][k] = sef[n];
            }
            long s = 0;
            for (int i = 1; i <= k; i++) {
                s += search(n - i, k);
                if (s >= mod) s -= mod;
            }
            return dp[n][k] = s;
        }

        public void solve(Scanner sc, PrintWriter pw) throws IOException {
            int n = sc.nextInt();
            int k = sc.nextInt();
            calc(n);
            long sum = 0;
            long inv2 = power(2, mod - 2);
            for (int i = 1; i <= n; i++) {
                int otherlen = k % i == 0 ? k / i - 1 : k / i;
                if (otherlen > n) otherlen = n;
                sum += subdp[n][i] * dp[n][otherlen] % mod * inv2 % mod;
                if (sum >= mod) sum -= mod;
            }
            pw.println(sum);
        }

        int mod = 998244353;

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){  br = new BufferedReader(new InputStreamReader(s));}

        public Scanner(FileReader s) throws FileNotFoundException {br = new BufferedReader(s);}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public int nextInt() throws IOException {return Integer.parseInt(next());}

        public long nextLong() throws IOException {return Long.parseLong(next());}

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException { return Double.parseDouble(next()); }

        public boolean ready() throws IOException {return br.ready();}
    }
}

import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main
{
    static MyScanner scan;
    static PrintWriter pw;
    static long dp[][][] = new long[501][2][501];
    static long MOD = 998244353;
    public static void main(String[] args) {
        new Thread(null,null,"_",1<<25)
        {
           public void run()
           {
               try
               {
                   solve();
               }
               catch(Exception e)
               {
                   e.printStackTrace();
                   System.exit(1);
               }
           }
        }.start();
    }
    static void solve() throws IOException
    {
        scan = new MyScanner();
        pw = new PrintWriter(System.out,true);
        StringBuilder sb = new StringBuilder();
        int n = ni();
        int k = ni();
        long ans=0;
	for(int i=0;i<501;++i)
            for(int j=0;j<2;++j)
                Arrays.fill(dp[i][j],-1);
	for(int i=1;i<=n;i++)
        {
		for(int j=1;j<=n;j++)
                {
			if(i*j<k)
                        {
				long tv=(f(n,0,i)*2);
				long temp=f(n,0,j);
				ans=ans+tv*temp;
				if(ans>=MOD) ans%=MOD;
			}
			else break;
		}
	}
	pl(ans);
        pw.flush();
        pw.close();
    }
    static long f(int x,int t,int left){
	if(x<0) return 0;
	if(x==0){
		if(t==1) return 1;
		return 0;
	}
	if(dp[x][t][left]!=-1)
            return dp[x][t][left];
	long ans=0;
	for(int i=1;i<=left;++i){
		if(x-i<0) break;
		ans=(ans+f(x-i,(t|(i==left?1:0)),left));
		if(ans>=MOD) ans-=MOD;
	}
	return dp[x][t][left]=ans;
    }
    static int ni() throws IOException
    {
        return scan.nextInt();
    }
    static long nl() throws IOException
    {
        return scan.nextLong();
    }
    static double nd() throws IOException
    {
        return scan.nextDouble();
    }
    static String ne() throws IOException
    {
        return scan.next();
    }
    static String nel() throws IOException
    {
        return scan.nextLine();
    }
    static void pl()
    {
        pw.println();
    }
    static void p(Object o)
    {
        pw.print(o+" ");
    }
    static void pl(Object o)
    {
        pw.println(o);
    }
    static void psb(StringBuilder sb)
    {
        pw.print(sb);
    }
    static class MyScanner
    {
        BufferedReader br;
        StringTokenizer st;
        MyScanner()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String nextLine()throws IOException
        {
            return br.readLine();
        }
        String next() throws IOException
        {
            if(st==null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }
        int nextInt() throws IOException
        {
            return Integer.parseInt(next());
        }
        long nextLong() throws IOException
        {
            return Long.parseLong(next());
        }
        double nextDouble() throws IOException
        {
            return Double.parseDouble(next());
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class E1027 {
	static int N,K, max1,max2;
	static final int MOD = 998244353;
	static int[][][] memo1;
	static int[][] memo2;
	public static void main(String[] args) {
		FS scan = new FS(System.in);
		N = scan.nextInt();
		K = scan.nextInt();

		memo1 = new int[2][N][N+1];
		memo2 = new int[N][N+1];
		long SOL = 0;
		int prevMax2 = -1;
		for(int i=1;i<Math.min(K, N+1);i++){
			max1 = i;
			max2 = (K+i-1)/i - 1;
			max2 = Math.min(max2, N);
			for(int j=0;j<2;j++)
				for(int k=0;k<N;k++)
					Arrays.fill(memo1[j][k], -1);
			if(prevMax2 != max2)
				for(int j=0;j<N;j++)Arrays.fill(memo2[j], -1);

			prevMax2 = max2;
			long A = 2*solve1(1,i-1,0);
			long B = solve2(1,max2-1);
			SOL += ((A*B)%MOD);
			SOL %= MOD;
		}
		System.out.println(SOL);

	}
	private static int solve1(int idx, int cnt, int flag) {
		if(idx == N) {
			return flag == 1 || cnt == 0? 1 : 0;
		}
		if(memo1[flag][idx][cnt] != -1) return memo1[flag][idx][cnt];
		int sum = 0;
		if(cnt > 0) {
			sum += solve1(idx+1,cnt-1,cnt == 1 || flag == 1? 1 : 0);
			sum %= MOD;
		}
		sum += solve1(idx+1,max1-1,flag==1 || cnt == 0 ? 1 : 0);
		sum %= MOD;
		return memo1[flag][idx][cnt] = sum;
	}

	private static int solve2(int idx, int cnt) {
		if(idx == N) return 1;
		if(memo2[idx][cnt] != -1) return memo2[idx][cnt];

		int sum = 0;
		if(cnt != 0) {
			sum += solve2(idx+1,cnt-1);
		}
		sum += solve2(idx+1,max2-1);
		sum%= MOD;
		return memo2[idx][cnt] = sum;
	}
	private static class FS {
		BufferedReader br;
		StringTokenizer st;
		public FS(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
		}
		String next(){
			while(st==null||!st.hasMoreElements()){
				try{st = new StringTokenizer(br.readLine());}
				catch(IOException e){e.printStackTrace();}
			}
			return st.nextToken();
		}
		int nextInt() {return Integer.parseInt(next());}
		long nextLong() {return Long.parseLong(next());}
		double nextDouble() { return Double.parseDouble(next());}
	}
}

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

public class E implements Runnable{
	public static void main (String[] args) {new Thread(null, new E(), "_cf", 1 << 28).start();}

	int MOD = 998244353;

	public void run() {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		System.err.println("Go!");

		int n = fs.nextInt();
		int k = fs.nextInt();
		if(Math.min(n, k) == 1) {
			System.out.println(0);
			return;
		}

		int[] prefDP = new int[n + 1];
		int[] dp = new int[n + 1];
		for(int len = 1; len <= n; len++) {
			int[] dp2 = new int[n + 1];
			int sum = 0;
			for(int i = 1; i <= n; i++) {
				if(i <= len) {
					dp2[i] = add(sum, 1);
				}
				else {
					sum = sub(sum, dp2[i-len-1]);
					dp2[i] = sum;
				}
				sum = add(sum, dp2[i]);
			}
			prefDP[len] = dp2[n];
			dp[len] = sub(prefDP[len], prefDP[len-1]);
		}

		int res = 0;
		for(int i = 1; i <= n; i++)
			for(int j = 1; j <= n; j++)
				if(i * j < k) {
					res = add(res, mult(dp[i], dp[j]));
				}

		res = mult(res, 2);
		out.println(res);
		out.close();
	}

	int mult(int a, int b) {
		long c = a % MOD;
		c *= b%MOD;
		return (int)(c % MOD);
	}

	int sub(int a, int b) {
		return ((a%MOD) - (b%MOD) + MOD) % MOD;
	}

	int add(int a, int b) {
		return ((a%MOD) + (b%MOD))%MOD;
	}

	void sort (int[] a) {
		int n = a.length;
		for(int i = 0; i < 50; i++) {
			Random r = new Random();
			int x = r.nextInt(n), y = r.nextInt(n);
			int temp = a[x];
			a[x] = a[y];
			a[y] = temp;
		}
		Arrays.sort(a);
	}

	class FastScanner {
		public int BS = 1<<16;
		public char NC = (char)0;
		byte[] buf = new byte[BS];
		int bId = 0, size = 0;
		char c = NC;
		double num = 1;
		BufferedInputStream in;

		public FastScanner() {
			in = new BufferedInputStream(System.in, BS);
		}

		public FastScanner(String s) throws FileNotFoundException {
			in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
		}

		public char nextChar(){
			while(bId==size) {
				try {
					size = in.read(buf);
				}catch(Exception e) {
					return NC;
				}
				if(size==-1)return NC;
				bId=0;
			}
			return (char)buf[bId++];
		}

		public int nextInt() {
			return (int)nextLong();
		}

		public long nextLong() {
			num=1;
			boolean neg = false;
			if(c==NC)c=nextChar();
			for(;(c<'0' || c>'9'); c = nextChar()) {
				if(c=='-')neg=true;
			}
			long res = 0;
			for(; c>='0' && c <='9'; c=nextChar()) {
				res = (res<<3)+(res<<1)+c-'0';
				num*=10;
			}
			return neg?-res:res;
		}

		public double nextDouble() {
			double cur = nextLong();
			return c!='.' ? cur:cur+nextLong()/num;
		}

		public String next() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c>32) {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public String nextLine() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c!='\n') {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public boolean hasNext() {
			if(c>32)return true;
			while(true) {
				c=nextChar();
				if(c==NC)return false;
				else if(c>32)return true;
			}
		}

		public int[] nextIntArray(int n) {
			int[] res = new int[n];
			for(int i = 0; i < n; i++) res[i] = nextInt();
			return res;
		}

	}

}

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

public class E implements Runnable{
	public static void main (String[] args) {new Thread(null, new E(), "_cf", 1 << 28).start();}

	int MAX = 511, MOD = 998244353, INV = 499122177;

	public void run() {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		System.err.println("Go!");

		int n = fs.nextInt();
		int k = fs.nextInt();
		if(n == 1) {
			System.out.println(0);
			return;
		}

		int[][] dp = new int[MAX][MAX];
		dp[1][1] = 2;
		for(int pos = 0; pos < n; pos++) {
			int[][] ndp = new int[MAX][MAX];

			for(int i = 1; i <= Math.min(k, n); i++) {
				for(int j = 1; j <= Math.min(k, n); j++) {
					int nm = Math.max(i, j+1);
					ndp[nm][j+1] = add(ndp[nm][j+1], dp[i][j]);
					ndp[i][1] = add(ndp[i][1], dp[i][j]);

				}
			}
			if(pos != n-1)
				dp = ndp;
		}

		int[] nums = new int[MAX];
		int[] div2 = new int[MAX];
		for(int i = 1; i <= Math.min(n, k); i++) {
			for(int j = 1; j <= Math.min(n, k); j++) {
				nums[i] = add(nums[i], dp[i][j]);
			}
		}
		for(int i = 1; i <= n; i++) div2[i] = mult(nums[i], INV);

		int res = 0;
		for(int i = 1; i <= Math.min(n, k); i++) {
			for(int j = 1; j <= Math.min(n, k); j++) {
				if(i * j < k) {
					res = add(res, mult(2, mult(div2[i], div2[j])));
				}
			}
		}

		out.println(res);
		out.close();
	}

	int mult(int a, int b) {
		long aa = a;
		if(aa >= MOD) aa -= MOD;
		if(b >= MOD) b -= MOD;
		aa *= b;
		if(aa >= MOD) aa %= MOD;
		return (int)aa;
	}

	int add(int a, int b) {
		if(a >= MOD) a -= MOD;
		if(b >= MOD) b -= MOD;
		a += b;
		if(a >= MOD) a-= MOD;
		return a;
	}

	void sort (int[] a) {
		int n = a.length;
		for(int i = 0; i < 50; i++) {
			Random r = new Random();
			int x = r.nextInt(n), y = r.nextInt(n);
			int temp = a[x];
			a[x] = a[y];
			a[y] = temp;
		}
		Arrays.sort(a);
	}

	class FastScanner {
		public int BS = 1<<16;
		public char NC = (char)0;
		byte[] buf = new byte[BS];
		int bId = 0, size = 0;
		char c = NC;
		double num = 1;
		BufferedInputStream in;

		public FastScanner() {
			in = new BufferedInputStream(System.in, BS);
		}

		public FastScanner(String s) throws FileNotFoundException {
			in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
		}

		public char nextChar(){
			while(bId==size) {
				try {
					size = in.read(buf);
				}catch(Exception e) {
					return NC;
				}
				if(size==-1)return NC;
				bId=0;
			}
			return (char)buf[bId++];
		}

		public int nextInt() {
			return (int)nextLong();
		}

		public long nextLong() {
			num=1;
			boolean neg = false;
			if(c==NC)c=nextChar();
			for(;(c<'0' || c>'9'); c = nextChar()) {
				if(c=='-')neg=true;
			}
			long res = 0;
			for(; c>='0' && c <='9'; c=nextChar()) {
				res = (res<<3)+(res<<1)+c-'0';
				num*=10;
			}
			return neg?-res:res;
		}

		public double nextDouble() {
			double cur = nextLong();
			return c!='.' ? cur:cur+nextLong()/num;
		}

		public String next() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c>32) {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public String nextLine() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c!='\n') {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public boolean hasNext() {
			if(c>32)return true;
			while(true) {
				c=nextChar();
				if(c==NC)return false;
				else if(c>32)return true;
			}
		}

		public int[] nextIntArray(int n) {
			int[] res = new int[n];
			for(int i = 0; i < n; i++) res[i] = nextInt();
			return res;
		}

	}

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Edu_49E {

	static final long MOD = 998244353;

	public static void main(String[] args) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter printer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		StringTokenizer inputData = new StringTokenizer(reader.readLine());
		int N = Integer.parseInt(inputData.nextToken());
		int K = Integer.parseInt(inputData.nextToken());

		long[] ans = new long[N + 1];

		long[] dp = new long[N + 1];

		for (int cMaxR = 1; cMaxR <= N; cMaxR++) {
			Arrays.fill(dp, 0);
			dp[0] = 2;
			long cSum = 2;

			for (int i = 1; i <= N; i++) {
				dp[i] = cSum;
				cSum = (cSum + dp[i]) % MOD;
				if (i - cMaxR >= 0) {
					cSum = (cSum - dp[i - cMaxR] + MOD) % MOD;
				}
			}
			ans[cMaxR] = dp[N];
		}

		long fAns = 0;
		for (int side1 = 1; side1 <= Math.min(K, N); side1++) {
			long cntWays = (ans[side1] - ans[side1 - 1] + MOD) % MOD;
			long mWays;
			if ((K + side1 - 1) / side1 > N) {
				mWays = ans[N];
			} else {
				mWays = ans[(K + side1 - 1) / side1 - 1];
			}
			fAns = (fAns + cntWays * mWays % MOD) % MOD;
		}
		fAns = (fAns * 499122177) % MOD;
		printer.println(fAns);
		printer.close();
	}
}

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

public class Main {
	public static void main(String args[]) {new Main().run();}

	FastReader in = new FastReader();
	PrintWriter out = new PrintWriter(System.out);
	void run(){
		work();
		out.flush();
	}
	long mod=998244353;
	long gcd(long a,long b) {
		return b==0?a:gcd(b,a%b);
	}
	void work() {
		int n=in.nextInt();
		int k=in.nextInt();
		long[][] dp=new long[n][n+1];
		for(int i=0;i<n;i++) {
			for(int j=1;j<=n;j++) {
				if(i==0)dp[0][j]=1;
				else {
					if(j>i) dp[i][j]=dp[i-1][j]*2;
					else {//j-1,j-2,...,j-k;
						dp[i][j]=2*dp[i-1][j]-(i-j-1<0?1:dp[i-j-1][j]);
					}
					dp[i][j]%=mod;
				}
			}
		}
		long[] f=new long[n+1];
		long ret=0;
		for(int i=1;i<=n;i++) {
			f[i]=(dp[n-1][i]-dp[n-1][i-1]+mod)%mod;
		}
		for(int i=1;i<=n;i++) {
			for(int j=1;i*j<k&&j<=n;j++) {
				ret+=f[i]*f[j];
				ret=ret%mod;
			}
		}
		out.println((ret*2)%mod);
	}
}

class FastReader
{
	BufferedReader br;
	StringTokenizer st;

	public FastReader()
	{
		br=new BufferedReader(new InputStreamReader(System.in));
	}

	public String next()
	{
		if(st==null || !st.hasMoreElements())
		{
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

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

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

import java.lang.*;
import java.math.*;
import java.util.*;
import java.io.*;

public class Main {
    void solve() {
        int n=ni(),k=ni();
        int dp[][][]=new int[2][n+1][n+1];

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

        dp[1][1][1]=1;

        dp1[1][1]=1;

        int M=998244353;
        long ans=0;
        for(int i=2;i<=n;i++){
            for(int j=1;j<=i;j++){
                Arrays.fill(dp[i%2][j],0);
            }
            Arrays.fill(dp1[i%2],0);
            for(int j=1;j<i;j++){
                for(int l=1;l<=j;l++){
                    dp[i%2][Math.max(j,l+1)][l+1]=add(dp[i%2][Math.max(j,l+1)][l+1],dp[(i-1)%2][j][l],M);

                    dp[i%2][j][1]=add(dp[i%2][j][1],dp[(i-1)%2][j][l],M);

                }
            }
            for(int j=1;j<=i;j++) {
                for(int l=1;l<=j;l++) dp1[i%2][j]=add(dp1[i%2][j],dp[i%2][j][l],M);

            }
        }

        for(int l=1;l<=n;l++){
            for(int r=1;r<=n;r++){
                if(l*r<k)
                ans+=mul(2,mul(dp1[n%2][l],dp1[n%2][r],M),M);
                if(ans>=M) ans-=M;
            }
        }

        pw.println(ans);

    }
    int add(int x,int y,int M){
        x+=y;
        if(x>=M) x-=M;
        return x;
    }
    long mul(long x,long y,int M){
        x*=y;
        if(x>=M) x%=M;
        return x;
    }

    long M=(long)1e9+7;
    InputStream is;
    PrintWriter pw;
    String INPUT = "";
    void run() throws Exception {
        is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        pw = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        pw.flush();
        if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");

    }

    public static void main(String[] args) throws Exception { new Main().run(); }

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
    private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;

public class E2 {

	static int N;
	static int K;
	static int mod = 998244353;
	static long modInvOf2;
	static int dp[][][][];
	public static void main(String[] args) {
		JS in = new JS();
		N = in.nextInt();
		K = in.nextInt();
		modInvOf2 = modInv(2, mod);
		dp = new int[2][2][N+1][N+1];
		for(int a[][][] : dp) {
			for(int b[][] : a) {
				for(int c[] : b) {
					Arrays.fill(c, -1);
				}
			}
		}
		long regular[] = new long[N+1];
		for(int run = 1; run <= N; run++) {
			regular[run] = go(1, run==1?1:0, 1, 1, run) + go(0, run==1?1:0, 1, 1, run);
			if(regular[run] >= mod) regular[run] -= mod;
		}
		long other[] = new long[N+1];
		for(int i = 1; i <= N; i++) {
			for(int j = 1; j <= i; j++) {
				other[i] += regular[j];
				other[i] %= mod;
			}
		}

		long res = 0;
		for(int run = 1; run <= N; run++) {
			long max = K/run;
			if(K%run == 0) max--;
			if(max == 0) continue;
			res += (regular[run]*other[ Math.min(N,(int)max)])%mod;
			if(res >= mod) res -= mod;
		}
		res = ((res*modInvOf2)%mod+mod)%mod;
		System.out.println(res);

	}
	static int go(int bit, int have, int index, int cur, int goal) {
		if(index >= N) return have;
		if(dp[bit][have][index][cur] != -1) return dp[bit][have][index][cur];
//		//take
		int take = -1;
		if(bit == 0) {
			take = go(1, have, index+1, 1, goal);
		}
		else {
			if(cur+1 > goal) take = 0;
			else take = go(1, have | (cur+1 == goal ? 1 : 0), index+1, cur+1, goal);
		}
		//leave
		int leave = -1;
		if(bit == 1) {
			leave = go(0, have, index+1, 1, goal);
		}
		else {
			if(cur+1 > goal) leave = 0;
			else leave = go(0, have | (cur+1 == goal? 1 : 0), index+1, cur+1, goal);
		}
		int res = take+leave;
		if(res >= mod) res -= mod;
		return dp[bit][have][index][cur] = res;
	}

	static long modInv(long x, long mod) {
		if(x == 1) return 1;
		long r = mod % x;
		return modInv(r, x % r, 0, 1, mod / x, x / r);
	}
	static long modInv(long a, long b, long y0, long y1, long q0, long q1) {
		long y2 = y0 - y1*q0;
		return b == 0 ? y2 : modInv(b, a % b, y1, y2, q1, a / b);
	}

	static class JS{
		public int BS = 1<<16;
		public char NC = (char)0;
		byte[] buf = new byte[BS];
		int bId = 0, size = 0;
		char c = NC;
		double num = 1;
		BufferedInputStream in;

		public JS() {
			in = new BufferedInputStream(System.in, BS);
		}

		public JS(String s) throws FileNotFoundException {
			in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
		}

		public char nextChar(){
			while(bId==size) {
				try {
					size = in.read(buf);
				}catch(Exception e) {
					return NC;
				}
				if(size==-1)return NC;
				bId=0;
			}
			return (char)buf[bId++];
		}

		public int nextInt() {
			return (int)nextLong();
		}

		public long nextLong() {
			num=1;
			boolean neg = false;
			if(c==NC)c=nextChar();
			for(;(c<'0' || c>'9'); c = nextChar()) {
				if(c=='-')neg=true;
			}
			long res = 0;
			for(; c>='0' && c <='9'; c=nextChar()) {
				res = (res<<3)+(res<<1)+c-'0';
				num*=10;
			}
			return neg?-res:res;
		}

		public double nextDouble() {
		    while(c!='.'&&c!='-'&&(c <'0' || c>'9')) c = nextChar();
		    boolean neg = c=='-';
		    if(neg)c=nextChar();
		    boolean fl = c=='.';
		    double cur = nextLong();
		    if(fl) return neg ? -cur/num : cur/num;
		    if(c == '.') {
			double next = nextLong();
			return neg ? -cur-next/num : cur+next/num;
		    }
		    else return neg ? -cur : cur;
		}

		public String next() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c>32) {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public String nextLine() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c!='\n') {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public boolean hasNext() {
			if(c>32)return true;
			while(true) {
				c=nextChar();
				if(c==NC)return false;
				else if(c>32)return true;
			}
		}
	}

}

//make sure to make new file!
import java.io.*;
import java.util.*;

public class E1027{

   public static long MOD = 998244353;

   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(System.out);

      StringTokenizer st = new StringTokenizer(f.readLine());

      int n = Integer.parseInt(st.nextToken());
      double m = Double.parseDouble(st.nextToken());

      if(m == 1.0){
         out.println("0");
         out.close();
         return;
      }

      long[] array = new long[n+1];            //number of ways such that max chunk is n
      array[0] = 0;
      array[1] = 1;

      for(int i = 2; i <= n; i++){
         long[][][] dp = new long[n][i][2];

         dp[0][0][0] = 1;

         for(int k = 0; k < n-1; k++){
            for(int j = 0; j < i; j++){
               for(int h = 0; h < 2; h++){
                  //simulate adding same color
                  if(j<i-1){
                     if(j == i-2){
                        dp[k+1][j+1][1] = (dp[k+1][j+1][1]+dp[k][j][h]+MOD)%MOD;
                     } else {
                        dp[k+1][j+1][h] = (dp[k+1][j+1][h]+dp[k][j][h]+MOD)%MOD;
                     }
                  }
                  //simulate adding different color
                  dp[k+1][0][h] = (dp[k+1][0][h]+dp[k][j][h]+MOD)%MOD;
               }
            }
         }

         for(int k = 0; k < i; k++){
            array[i] = (array[i] + dp[n-1][k][1]+MOD)%MOD;
         }
      }

      //psums
      long[] psums = new long[n+2];

      psums[0] = 0L;

      for(int k = 1; k <= n+1; k++){
         psums[k] = (psums[k-1]+array[k-1]+MOD)%MOD;
      }

      long answer = 0L;

      for(int k = 1; k <= n; k++){
         int i = Math.min(n,(int)Math.floor(m/(double)k));
         long prod = (array[k]*psums[i+1]+MOD)%MOD;
         answer = (answer + prod + MOD)%MOD;
      }

      answer = (answer*2 + MOD)%MOD;
      out.println(answer);

      out.close();
   }
}

//make sure to make new file!
import java.io.*;
import java.util.*;

public class E1027{

   public static long MOD = 998244353;

   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(System.out);

      StringTokenizer st = new StringTokenizer(f.readLine());

      int n = Integer.parseInt(st.nextToken());
      double m = Double.parseDouble(st.nextToken());

      long[] array = new long[n+1];            //number of ways such that max chunk is n
      array[0] = 0;
      array[1] = 1;

      for(int i = 2; i <= n; i++){
         long[][][] dp = new long[n][i][2];

         dp[0][0][0] = 1;

         for(int k = 0; k < n-1; k++){
            for(int j = 0; j < i; j++){
               for(int h = 0; h < 2; h++){
                  //simulate adding same color
                  if(j<i-1){
                     if(j == i-2){
                        dp[k+1][j+1][1] = (dp[k+1][j+1][1]+dp[k][j][h]+MOD)%MOD;
                     } else {
                        dp[k+1][j+1][h] = (dp[k+1][j+1][h]+dp[k][j][h]+MOD)%MOD;
                     }
                  }
                  //simulate adding different color
                  dp[k+1][0][h] = (dp[k+1][0][h]+dp[k][j][h]+MOD)%MOD;
               }
            }
         }

         for(int k = 0; k < i; k++){
            array[i] = (array[i] + dp[n-1][k][1]+MOD)%MOD;
         }
      }

      //psums
      long[] psums = new long[n+2];

      psums[0] = 0L;

      for(int k = 1; k <= n+1; k++){
         psums[k] = (psums[k-1]+array[k-1]+MOD)%MOD;
      }

      long answer = 0L;

      for(int k = 1; k <= n; k++){
         int i = Math.min(n,(int)Math.floor(m/(double)k));
         long prod = (array[k]*psums[i+1]+MOD)%MOD;
         answer = (answer + prod + MOD)%MOD;
      }

      answer = (answer*2 + MOD)%MOD;
      out.println(answer);

      out.close();
   }
}

//package com.company;

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

public class Main {
    static long TIME_START, TIME_END;
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        //        Scanner sc = new Scanner(new FileInputStream("Test.in"));
        PrintWriter pw = new PrintWriter(System.out);
        //        PrintWriter pw = new PrintWriter(new FileOutputStream("Test.out"));
        //        PrintWriter pw = new PrintWriter(new FileOutputStream("Test.in"));

        Runtime runtime = Runtime.getRuntime();
        long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
        TIME_START = System.currentTimeMillis();
        Task t = new Task();
        t.solve(sc, pw);
        TIME_END = System.currentTimeMillis();
        long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
        pw.close();
        System.out.println("Memory increased:" + (usedMemoryAfter-usedMemoryBefore) / 1000000 );
        System.out.println("Time used: " + (TIME_END - TIME_START) + ".");
    }

    public static class Task {

        public long[][] dp;
        public long[][] subdp;
        public long[] sef;

        public long power(long a, int b) {
            if (b == 0) return 1;
            if (b % 2 == 0) return power(a * a % mod, b >> 1);
            return a * power(a * a % mod, b >> 1) % mod;
        }

        public void calc(int n) {
            dp = new long[n + 1][n + 1];
            subdp = new long[n + 1][n + 1];
            sef = new long[n + 1];
            long t = 1;
            for (int i = 0; i < n + 1; i++) {
                sef[i] = t;
                t *= 2; t %= mod;
            }
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    search(i, j);
                }
            }
            subdp[n][1] = dp[n][1];
            for (int i = 1; i < n; i++) {
                subdp[n][i + 1] = dp[n][i + 1] - dp[n][i];
            }
        }

        public long search(int n, int k) {
            if (dp[n][k] != 0) {
                return dp[n][k];
            }
            if (k >= n) {
                return dp[n][k] = sef[n];
            }
            long s = 0;
            for (int i = 1; i <= k; i++) {
                s += search(n - i, k);
                if (s >= mod) s -= mod;
            }
            return dp[n][k] = s;
        }

        public void solve(Scanner sc, PrintWriter pw) throws IOException {
            int n = sc.nextInt();
            int k = sc.nextInt();
            calc(n);
            long sum = 0;
            long inv2 = power(2, mod - 2);
            for (int i = 1; i <= n; i++) {
                int otherlen = k % i == 0 ? k / i - 1 : k / i;
                if (otherlen > n) otherlen = n;
                sum += subdp[n][i] * dp[n][otherlen] % mod * inv2 % mod;
                if (sum >= mod) sum -= mod;
            }
            pw.println(sum);
        }

        int mod = 998244353;

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){  br = new BufferedReader(new InputStreamReader(s));}

        public Scanner(FileReader s) throws FileNotFoundException {br = new BufferedReader(s);}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public int nextInt() throws IOException {return Integer.parseInt(next());}

        public long nextLong() throws IOException {return Long.parseLong(next());}

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException { return Double.parseDouble(next()); }

        public boolean ready() throws IOException {return br.ready();}
    }
}

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

public class Main {
	public static void main(String args[]) {new Main().run();}

	FastReader in = new FastReader();
	PrintWriter out = new PrintWriter(System.out);
	void run(){
		work();
		out.flush();
	}
	long mod=998244353;
	long gcd(long a,long b) {
		return b==0?a:gcd(b,a%b);
	}
	void work() {
		int n=in.nextInt();
		int k=in.nextInt();
		long[][] dp=new long[n][n+1];
		for(int i=0;i<n;i++) {
			for(int j=1;j<=n;j++) {
				if(i==0)dp[0][j]=1;
				else {
					if(j>i) dp[i][j]=dp[i-1][j]*2;
					else {//j-1,j-2,...,j-k;
						dp[i][j]=2*dp[i-1][j]-(i-j-1<0?1:dp[i-j-1][j]);
						dp[i][j]%=mod;
					}
				}
			}
		}
		long[] f=new long[n+1];
		long ret=0;
		for(int i=1;i<=n;i++) {
			f[i]=(dp[n-1][i]-dp[n-1][i-1]+mod)%mod;
		}
		for(int i=1;i<=n;i++) {
			for(int j=1;i*j<k&&j<=n;j++) {
				ret+=f[i]*f[j];
				ret=ret%mod;
			}
		}
		out.println((ret*2)%mod);
	}
}

class FastReader
{
	BufferedReader br;
	StringTokenizer st;

	public FastReader()
	{
		br=new BufferedReader(new InputStreamReader(System.in));
	}

	public String next()
	{
		if(st==null || !st.hasMoreElements())
		{
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

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

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