//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.*;

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

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

// 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.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());
	}
}