#include<iostream>
#include<cassert>
using namespace std; 
typedef long long ll;


template <int N> 
struct modInt {
    long long val; 
    modInt(ll v){
        this->val = v%N; 
    }
    int toInt(){
        return this->val;
    }
    void operator=(const ll other){
    this->val = other%N;
}
   

};
template<int N> modInt<N> operator+(const modInt<N> &,const modInt<N> &);
template<int N> modInt<N> operator+(const modInt<N> &,const ll);
template<int N> modInt<N> operator*(const modInt<N> &,const modInt<N> &);
template<int N> modInt<N> operator*(const modInt<N> &,const ll);
template<int N> modInt<N> operator/(const modInt<N> &,const modInt<N> &);
template<int N> modInt<N> operator/(const modInt<N> &,const ll);
template<int N> modInt<N> binpow(const modInt<N> &,const int);
template<int N> modInt<N> inverse(const modInt<N> &);
template<int N> modInt<N> pw(const modInt<N> &,const int);

template<int N> modInt<N> operator+(const modInt<N> &a,const modInt<N> &b){
    return modInt<N>(a.val + b.val);
}

template<int N> modInt<N> operator+(const modInt<N> &a, const ll b){
    modInt<N> c(b); 
    return a+c;
}
template<int N> modInt<N> operator*(const modInt<N> &a,const modInt<N> &b){
    modInt<N> res(a.val*b.val); 
    return res;
}
template<int N> modInt<N> operator*(const modInt<N> &a, const ll b){
    modInt<N> c(b); 
    return a*c;
}
template<int N> modInt<N> operator/(const modInt<N> &a,const modInt<N> &b){
    modInt<N> c = inverse<N>(b); 
    return a*c;
}
template<int N> modInt<N> operator/(const modInt<N> &a, const ll b){
    modInt<N> c(b); 
    return a/c;
}

template<int N> modInt<N> inverse(const modInt<N> &a){
    return binpow(a,N-2);
}
template<int N> modInt<N> pw(const modInt<N> &a,int exp){
    if(exp<0){
        modInt<N> inverse = inverse(a);
        return binpow<N>(a,-exp); 
    }
    return binpow<N>(a,exp);
}


template<int N> modInt<N> binpow(const modInt<N> &a,int b){
    if(b==0){
        return modInt<N>(1);
    }
    modInt<N> v = binpow<N>(a,b/2);
    modInt<N> res = v*v;
    if(b%2==1){
        return a*res;
    }
    return res;
}

#include<bits/stdc++.h>


using namespace std;
typedef long long ll;
const ll mod = 998244353;



int main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
    int n,m;
    cin>>n>>m;

    vector<modInt<mod>> row(n+1,1);
    for(int i=1;i<=n;i++){
        row[i] = (row[i-1]*(n-i+1))/i;
    }
    vector<modInt<mod>> dp(m+1,0);
    dp[0] = 1; 
    for(int j=2;j<=m;j+=2){
        for(int i=0;i<=min(j,n);i+=2){
            dp[j]=dp[j]+(dp[(j-i)/2]*row[i]);
        }
    
    }
    cout<<dp[m].toInt()<<endl;


	return 0;
}
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define deb(...)
#endif
#define endl "\n"
#define pb push_back
// #define int long long
#define ll long long
#define pii pair<int,int>
#define F first
#define S second
#define all(c) c.begin(),c.end()
#define read(v) for(auto &it:v) cin>>it;
// const int inf = 1e18;
const int N   = 5e3 + 5;
const int mod = 998244353;
int maxi[12];
int n, m;
int ans = 0;
ll f[N], invf[N];

ll mpow(ll x, ll y) {
	ll res = 1;
	x = x % mod;
	while (y > 0) {
		if (y & 1) res = (res * x) % mod;
		y = y >> 1;
		x = (x * x) % mod;
	}
	return res;
}

ll modInv(ll n) {
	return mpow(n, mod - 2);
}

ll C(ll n, ll r) {
	if (r == 0) return 1;
	assert(n >= r);
	return (f[n] * invf[r] % mod * invf[n - r] % mod) % mod;
}

void fact() {
	f[0] = 1;
	invf[0] = 1;
	for (int i = 1; i < N; i++) {
		f[i] = (f[i - 1] * i) % mod;
		invf[i] = modInv(f[i]);
	}
}
namespace modop {
ll madd(ll a, ll b) {
	return (a + b) % mod;
}
ll msub(ll a, ll b) {
	return (((a - b) % mod) + mod) % mod;
}
ll mmul(ll a, ll b) {
	return ((a % mod) * (b % mod)) % mod;
}
ll minv(ll base) {
	return mpow(base, mod - 2);
}
ll mdiv(ll a, ll b) {
	return mmul(a, minv(b));
}
}

using namespace modop;
int dp[12][5005];
int go(int bit, int sum) {
	if (bit == 12) {
		if (sum == 0) {
			return 1;
		}
		else {
			return 0;
		}

	}
	if (dp[bit][sum] != -1) {
		return dp[bit][sum];
	}
	int ans = 0;
	int p = (1LL << bit);
	for (int i = 0; i <= maxi[bit]; i += 2) {
		int zx = i * p;
		if (zx <= sum) {
			int coeff = C(n, i);
			ans = madd(ans, mmul(coeff, go(bit + 1, sum - zx)));
		}
		else {
			break;
		}
	}

	return dp[bit][sum] = ans;

}
void testCase() {
	cin >> n >> m;
	fact();

	for (int i = 0; i <= 11; i++) {
		int max_take = min(n, m / (1 << i));
		maxi[i] = max_take;
	}
	memset(dp, -1, sizeof dp);
	cout << go(0, m) << endl;


}

int32_t main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	int  t = 1;
	// cin >> t;
	while (t--)testCase();
	return 0;
}