#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_ll.hpp>

#define rep(i,a,b) for(ll i=a;i<b;i++)
#define rrep(i,b,a) for(ll i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
double pi=acos(-1);
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front //deque
// #define mp make_pair
#define pq priority_queue
const ll mod=998244353;
#define f first
#define s second
#define pii pair< ll, ll >
#define vi vector<ll>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc ll t; cin >> t; while(t--)

// using namespace boost::multiprecision;
using namespace std;
void optimizeIO(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}


const ll N=1000005;
ll fact[N],invfact[N];
ll power(ll x,ll y){
  if(y<=0) return 1LL;
  ll z=power(x,y/2);
  if(y%2) return (((z*z)%mod)*x)%mod;
  return (z*z)%mod;
}
void pre(){
  fact[0]=invfact[0]=invfact[1]=fact[1]=1;
  rep(i,2,N) fact[i]=(i*fact[i-1])%mod;
  rep(i,2,N) invfact[i]=(invfact[i-1]*power(i,mod-2))%mod;
}
ll nCr(ll n,ll k){ return (((fact[n]*invfact[n-k])%mod)*invfact[k])%mod; }



const ll N1=1e6+1;
vector<ll> isprime(N1,1),prime;
void seive(){
  rep(i,2,sqrt(N1)+1){
      if(isprime[i]){
        for(ll j=i*i;j<N1;j+=i) isprime[j]=0;
        prime.pb(i);
      }
  }
  rep(i,sqrt(N1)+1,N1) if(isprime[i]) prime.pb(i);
}



struct dsu {
    vector<ll> par, rank;
    dsu(ll n): par(n+1), rank(n+1) {
        for (ll i = 0; i <= n; i++) {
            par[i] = i;
            rank[i]= 1;
        }
    }
    ll root(ll a) {
        if (a == par[a]) return a;
        return par[a] = root(par[a]);
    }
    void merge(ll a, ll b) {
        a = root(a);
        b = root(b);
        if (a == b) return;
        if (rank[a] > rank[b]) swap(a, b);
        par[b] = a;
    }
    set<ll> parent(ll n){
        set<ll> s;
        for(ll i=1;i<=n;i++){
            s.insert(root(i));
        }
        return s;
    }
};
void solve(){
  // ll n,k;
  // cin>>n>>k;
  // vector<vector<ll>> dp(n+1,vector<ll>(k+1,0));
  // rep(i,1,n+1) dp[i][1]=1;
  // rep(i,2,n+1){
  //   rep(k1,1,k+1){
  //     ll lim=i;
  //     if(k1==2) lim=(i%2==0?i/2:i/2);
  //     rep(j,1,lim+1){
  //       if(i-j>=0 ) dp[i][k1]=(dp[i][k1]+(dp[j][k1-1]*dp[i-j][1]))%mod;
  //     }
  //   }
  // }
  // cout<<dp[n][k]<<endl;
  // int mod=998244353;
  // int n,k,f[3010][3010];
  // scanf("%d %d",&n,&k);
  // f[0][k]=1;
	// for(int i=0;i<n;i++)
	// 	for(int j=1;j<=n;j++) if(f[i][j])
	// 	{
	// 		if(2*j<=n) (f[i][2*j]+=f[i][j])%=mod;
	// 		(f[i+1][j-1]+=f[i][j])%=mod;
	// 	}
	// printf("%d",f[n][0]);

  ll n,kl;
  cin>>n>>kl;
  vector<vector<ll>> dp(n+1,vector<ll>(n+1,0));
  dp[1][1]=1;
  rep(i,2,n+1){
    rrep(k,n+1,1){
      dp[i][k]=(dp[i][k]+dp[i-1][k-1]+(2*k<=i?dp[i][2*k]:0))%mod;
    }
  }
  cout<<dp[n][kl]<<endl;
}

int32_t main(){
    optimizeIO();
    {solve();}
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define all(v) v.begin(), v.end()
#define sz(v) v.size()
#define INF 100000000000000 //10^14
template <typename T>
bool chmax(T &a, const T& b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
bool chmin(T &a, const T& b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 998244353;
struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%mod+mod)%mod){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
  if ((x += a.x) >= mod) x -= mod;
  return *this;
  }
  mint& operator-=(const mint a) {
  if ((x += mod-a.x) >= mod) x -= mod;
  return *this;
  }
  mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
  mint operator+(const mint a) const { return mint(*this) += a;}
  mint operator-(const mint a) const { return mint(*this) -= a;}
  mint operator*(const mint a) const { return mint(*this) *= a;}
  mint pow(ll t) const {
  if (!t) return 1;
  mint a = pow(t>>1);
  a *= a;
  if (t&1) a *= *this;
  return a;
  }
  // for prime mod
  mint inv() const { return pow(mod-2);}
  mint& operator/=(const mint a) { return *this *= a.inv();}
  mint operator/(const mint a) const { return mint(*this) /= a;}
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}

int main()
{
    ll N, K;
    cin >> N >> K;
    vector<vector<mint>> dp(N+2, vector<mint>(N+2, 0));
    dp.at(0).at(0) = 1;
    rep(i, N+1){
      for(ll j = N; j >= 0; j--){
        dp.at(i+1).at(j+1) += dp.at(i).at(j);
        if(j % 2 == 0 && j > 0){
          dp.at(i).at(j/2) += dp.at(i).at(j);
        }
      }
    }
    cout << dp.at(N).at(K) << endl;
}