#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC push_options
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
#include <xmmintrin.h>
#include <immintrin.h>
using namespace::std;
__attribute__((constructor))void init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
// #include <boost/multiprecision/cpp_dec_float.hpp>
// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// typedef mp::number<mp::cpp_dec_float<0>> cdouble;
// typedef mp::cpp_int cint;
template<typename T>using pbds=__gnu_pbds::tree<T,__gnu_pbds::null_type,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<typename T>using pbds_map=__gnu_pbds::tree<T,T,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<typename T,typename E>using hash_map=__gnu_pbds::gp_hash_table<T,E>;
template<typename T>using pqueue =__gnu_pbds::priority_queue<T, greater<T>,__gnu_pbds::rc_binomial_heap_tag>;
typedef long long lint;
#define INF (1LL<<60)
#define IINF (1<<30)
#define EPS (1e-10)
#define endl ('\n')
//#define MOD 1000000007LL
constexpr lint MOD=998244353LL;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
template<typename T>inline void numout(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i<INF/2?i:"INF";f=1;}cout<<endl;}
template<typename T>inline void numout2(T t){for(auto i:t)numout(i);}
template<typename T>inline void output(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i;f=1;}cout<<endl;}
template<typename T>inline void output2(T t){for(auto i:t)output(i);}
template<typename T>inline void _output(T t){bool f=0;for(lint i=0;i<t.size();i++){cout<<f?"":" "<<t[i];f=1;}cout<<endl;}
template<typename T>inline void _output2(T t){for(lint i=0;i<t.size();i++)output(t[i]);}
#define rep(i,n) for(lint i=0;i<lint(n);++i)
#define repi(i,a,b) for(lint i=lint(a);i<(lint)(b);++i)
#define rrep(i,n) for(lint i=lint(n)-1;i>=0;--i)
#define rrepi(i,a,b) for(lint i=lint(b)-1;i>=lint(a);--i)
#define irep(i) for(lint i=0;;++i)
#define all(n) begin(n),end(n)
#define dist(a,b,c,d) sqrt(pow(a-c,2)+pow(b-d,2))
inline lint gcd(lint A,lint B){return B?gcd(B,A%B):A;}
inline lint lcm(lint A,lint B){return A/gcd(A,B)*B;}
// inline cint cgcd(cint A,cint B){return B?cgcd(B,A%B):A;}
// inline cint clcm(cint A,cint B){return A/cgcd(A,B)*B;}
inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
const vector<lint> dx={1,0,-1,0,1,1,-1,-1};
const vector<lint> dy={0,1,0,-1,1,-1,1,-1};
#define SUM(v) accumulate(all(v),0LL)
auto call=[&](auto f,auto... args){return f(f,args...);};

// struct union_enumerate{
//     lint n;
//     vector<int>v;
//     union_enumerate(int n):n(n),v(n){
//         iota(v.begin(),v.end(),0);
//     }
//     void unite(int s,int t){
//         swap(v[s],v[t]);
//     }
//     vector<vector<int>> out(){
//         vector<vector<int>>ret;
//         vector<bool>visited(n,0);
//         for(int i=0;i<n;i++){
//             if(visited[i])continue;
//             else{
//                 ret.emplace_back({});
//                 for(int t=i;v[t]!=i;t=v[t]){
//                     ret.back.emplace_back(t);
//                 }
//             }
//         }
//         return ret;
//     }
// };
class mint {
  using u64 = std::uint_fast64_t;
    public:
    u64 a;
    constexpr mint(const long long x = 0)noexcept:a(x>=0?x%get_mod():get_mod()-(-x)%get_mod()){}
    constexpr u64 &value()noexcept{return a;}
    constexpr const u64 &value() const noexcept {return a;}
    constexpr mint operator+(const mint rhs)const noexcept{return mint(*this) += rhs;}
    constexpr mint operator-(const mint rhs)const noexcept{return mint(*this)-=rhs;}
    constexpr mint operator*(const mint rhs) const noexcept {return mint(*this) *= rhs;}
    constexpr mint operator/(const mint rhs) const noexcept {return mint(*this) /= rhs;}
    constexpr mint &operator+=(const mint rhs) noexcept {
        a += rhs.a;
        if (a >= get_mod())a -= get_mod();
        return *this;
    }
    constexpr mint &operator-=(const mint rhs) noexcept {
        if (a<rhs.a)a += get_mod();
        a -= rhs.a;
        return *this;
    }
    constexpr mint &operator*=(const mint rhs) noexcept {
        a = a * rhs.a % get_mod();
        return *this;
    }
    constexpr mint operator++(int n) noexcept {
        a += 1;
        if (a >= get_mod())a -= get_mod();
        return *this;
    }
    constexpr mint operator--(int n) noexcept {
        if (a<1)a += get_mod();
        a -= 1;
        return *this;
    }
    constexpr mint &operator/=(mint rhs) noexcept {
        u64 exp=get_mod()-2;
        while (exp) {
            if (exp % 2) {
                *this *= rhs;
            }
            rhs *= rhs;
            exp /= 2;
        }
        return *this;
    }
    constexpr bool operator==(mint x) noexcept {
        return a==x.a;
    }
    constexpr bool operator!=(mint x) noexcept {
        return a!=x.a;
    }
    constexpr static int root(){
        mint root = 2;
        while(root.pow((get_mod()-1)>>1).a==1)root++;
        return root.a;
    }
    constexpr mint pow(long long n){
        long long x=a;
        mint ret = 1;
        while(n>0) {
            if(n&1)(ret*=x);
            (x*=x)%=get_mod();
            n>>=1;
        }
        return ret;
    }
    constexpr mint inv(){
        return pow(get_mod()-2);
    }
    static vector<mint> fac,ifac;
    static bool init;
    void build(){
        init=0;
        fac.resize(10101011);
        ifac.resize(10101011);
        fac[0]=1,ifac[0]=1;
        for(int i=1;i<10101011;i++)fac[i]=fac[i-1]*i;
        ifac[10101010]=fac[10101010].inv();
        for(int i=10101009;i>=0;i--)ifac[i]=ifac[i+1]*(i+1);
    }
    mint comb(lint b){
        if(init)build();
        if(a==0&&b==0)return 1;
        if((lint)a<b||a<0)return 0;
        return fac[a]*ifac[a-b]*ifac[b];
    }
    mint fact(){
        if(init)build();
        return fac[a];
    }
    mint fact_inv(){
        if(init)build();
        return ifac[a];
    }
    friend ostream& operator<<(ostream& lhs, const mint& rhs) noexcept {
        lhs << rhs.a;
        return lhs;
    }
    friend istream& operator>>(istream& lhs,mint& rhs) noexcept {
        lhs >> rhs.a;
        return lhs;
    }
    constexpr static u64 get_mod(){return MOD;}
};
vector<mint> mint::fac;
vector<mint> mint::ifac;
bool mint::init=1;

// template <typename T>
// inline void fwt(vector<T>& f)noexcept{
//     int n = f.size();
//     for (int i = 1; i < n; i <<= 1){
//         for (int j = 0; j < n; j++) {
//             if ((j & i) == 0) {
//                 T x = f[j], y = f[j | i];
//                 f[j] = x + y, f[j | i] = x - y;
//             }
//         }
//     }
// }
// template <typename T>
// inline void ifwt(vector<T>& f)noexcept{
//     int n = f.size();
//     for (int i = 1; i < n; i <<= 1) {
//         for (int j = 0; j < n; j++) {
//             if ((j & i) == 0) {
//                 T x = f[j], y = f[j | i];
//                 f[j] = (x + y) / 2, f[j | i] = (x - y) / 2;
//             }
//         }
//     }
// }

// int n,x;
// vector<mint> memo[11][2][2048];
// //f自由になったか
// vector<mint> v(int h,int f,int n){
//     if(memo[h][f][n].size()!=0){
//         return memo[h][f][n];
//     }
//     if(h==0){
//         auto d=(!f&&(((x>>h)&1)==0))?vector<mint>{1,0}:vector<mint>{n/2+1,(n+1)/2};
//         return d;
//     }
//     if(!f&&(((x>>h)&1)==0)){
//         auto d=v(h-1,f,n);
//         return memo[h][f][n]=d;
//     }
//     if(n==0){
//         return memo[h][f][n]=vector<mint>{1,0};
//     }
//     vector<mint>res(1<<(h+1),0);
//     vector<mint> l2(1<<int(h+log2(n)+1),0);
//     vector<mint> r2(1<<int(h+log2(n)+1),0);
//     vector<mint> l3(1<<int(h+log2(n)+1),0);
//     vector<mint> r3(1<<int(h+log2(n)+1),0);

//     rep(i,n+1){
//         auto l=v(h-1,f|((x>>h)&1),n-i);
//         auto r=v(h-1,f,i);
//         if(i%2){
//             rep(j,l.size()){
//                 l2[j+i*l.size()]=l[j];
//                 r2[j+i*r.size()]=r[j];
//             }
//         }else{
//             rep(j,l.size()){
//                 l3[j+i*l.size()]=l[j];
//                 r3[j+i*r.size()]=r[j];
//             }
//         }
//     }
//     fwt(l2);
//     fwt(r2);
//     rep(i,l2.size())l2[i]*=r2[i];
//     ifwt(l2);
//     fwt(l3);
//     fwt(r3);
//     rep(i,l3.size())l3[i]*=r3[i];
//     ifwt(l3);
//     rep(i,1<<h){
//         res[i]=l2[i];
//         res[i+(1<<h)]=l3[i];
//     }
//     return memo[h][f][n]=res;
// }

int main(){
    int n,x;
    cin>>n>>x;
    vector<vector<mint>>dp(n+1,vector<mint>(512,0));
    dp[0][0]=1;
    // if(x==0){
    //     cout<<1<<endl;
    //     return 0;
    // }
    rep(i,x+1){
        vector<vector<mint>>tmp(n+1,vector<mint>(512,0));
        rep(j,n+1)rep(k,512){
            if(j)tmp[j][k^i]+=dp[j-1][k];
            tmp[j][k]+=dp[j][k];
        }
        swap(dp,tmp);
    }
    mint ans=0;
    rep(i,n+1){
        if((n-i)%2)continue;
        int t=(n-i)/2;
        ans+=dp[i][x]*mint(x+t).comb(t);
    }
    cout<<ans<<endl;
}


Measured memory_bytes: 164724