#include<stdio.h>
#include<algorithm>
#include<numeric>
#include<random>
#include<chrono>
typedef unsigned int uint;
typedef unsigned long long ull;
constexpr uint mod{998244353};
constexpr uint plus(const uint &x,const uint &y) {
    if(x+y>=mod) {
        return x+y-mod;
    }
    return x+y;
}
constexpr uint minus(const uint &x,const uint &y) {
    if(x<y) {
        return x-y+mod;
    }
    return x-y;
}
constexpr uint power(uint x,uint y) {
    uint s(1);
    while(y>0) {
        if(y&1) {
            s=ull(s)*x%mod;
        }
        x=ull(x)*x%mod;
        y>>=1;
    }
    return s;
}
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
template<typename Tp>
inline Tp rand(const Tp &l,const Tp &r) {
    return std::uniform_int_distribution<Tp>(l,r)(rng);
}
constexpr bool check(const uint &n,const uint &s) {
    int j(0);
    for(uint i=0;i!=n;i++) {
        if((j+=s>>i&1?1:-1)<0) {
            return false;
        }
    }
    return j==0;
}
uint id[1<<14|1];
constexpr uint maxn{429};
struct matrix {
    uint n;
    uint a[maxn][maxn];
    constexpr matrix():n{},a{} {}
    constexpr matrix(const uint &_n):n{_n},a{} {}
    constexpr void clear() {
        for(uint i=0;i!=n;i++) {
            for(uint j=0;j!=n;j++) {
                a[i][j]=0;
            }
        }
    }
    constexpr void resize(const uint &_n) {
        n=_n,clear();
    }
    constexpr matrix mul(const matrix &x) const {
        matrix z(x.n);
        for(uint i=0;i!=z.n;i++) {
            for(uint j=0;j!=z.n;j++) {
                for(uint k=0;k!=z.n;k++) {
                    z.a[i][k]=(z.a[i][k]+ull(a[i][j])*x.a[j][k])%mod;
                }
            }
        }
        return z;
    }
    constexpr matrix &rmul(const matrix &x) {
        const matrix y(*this);
        clear();
        for(uint i=0;i!=n;i++) {
            for(uint j=0;j!=n;j++) {
                for(uint k=0;k!=n;k++) {
                    a[i][k]=(a[i][k]+ull(y.a[i][j])*x.a[j][k])%mod;
                }
            }
        }
        return *this;
    }
    constexpr matrix &lmul(const matrix &x) {
        const matrix y(*this);
        clear();
        for(uint i=0;i!=n;i++) {
            for(uint j=0;j!=n;j++) {
                for(uint k=0;k!=n;k++) {
                    a[i][k]=(a[i][k]+ull(x.a[i][j])*y.a[j][k])%mod;
                }
            }
        }
        return *this;
    }
    constexpr matrix &square() {
        const matrix y(*this);
        clear();
        for(uint i=0;i!=n;i++) {
            for(uint j=0;j!=n;j++) {
                for(uint k=0;k!=n;k++) {
                    a[i][k]=(a[i][k]+ull(y.a[i][j])*y.a[j][k])%mod;
                }
            }
        }
        return *this;
    }
};
struct vector {
    uint n;
    uint a[maxn];
    constexpr vector():n{},a{} {}
    constexpr vector(const uint &_n):n{_n},a{} {}
    constexpr void clear() {
        for(uint i=0;i!=n;i++) {
            a[i]=0;
        }
    }
    constexpr void resize(const uint &_n) {
        n=_n,clear();
    }
    constexpr vector &lmul(const matrix &x) {
        const vector y(*this);
        clear();
        for(uint i=0;i!=n;i++) {
            for(uint j=0;j!=n;j++) {
                a[i]=(a[i]+ull(x.a[i][j])*y.a[j])%mod;
            }
        }
        return *this;
    }
    constexpr uint dot(const vector &x) const {
        uint s(0);
        for(uint i=0;i!=n;i++) {
            s=(s+ull(a[i])*x.a[i])%mod;
        }
        return s;
    }
};
namespace dsu {
    uint fa[60];
    inline void init(const uint &n) {
        std::iota(fa,fa+n,0);
    }
    uint getf(const uint &x) {
        return fa[x]==x?x:fa[x]=getf(fa[x]);
    }
    inline void merge(const uint &x,const uint &y) {
        fa[getf(y)]=getf(x);
    }
}
namespace linear {
    constexpr uint N{860};
    inline uint BM(const uint &n,const uint *const f,uint *const g) {
        static uint h[N+5]{},_h[N+5]{};
        std::fill(g,g+n+1,0);
        std::fill(h,h+n+1,0);
        uint pos(-1),lst(0),del(0);
        uint len(0);
        for(uint i=1;i<=n;i++) {
            uint tmp(0);
            for(uint j=1;j<=len;j++) {
                tmp=(tmp+ull(f[i-j])*g[j])%mod;
            }
            if(tmp==f[i]) {
                continue;
            }
            if(pos==-1) {
                len=i,pos=i;
                del=f[i];
                continue;
            }
            const uint _del(minus(f[i],tmp));
            const uint coef(ull(_del)*power(del,mod-2)%mod);
            del=_del;
            std::copy(g,g+len+1,_h);
            for(uint j=1;j<=lst;j++) {
                g[j+i-pos]=(g[j+i-pos]+ull(mod-coef)*h[j])%mod;
            }
            g[i-pos]=plus(g[i-pos],coef);
            std::tie(lst,len)=std::make_tuple(len,std::max(len,lst+i-pos));
            std::copy(_h,_h+lst+1,h);
            pos=i;
        }
        return len;
    }
}
namespace poly {
    constexpr uint N{430};
    inline void multiply(const uint &n,const uint *const f,const uint *const g,uint *const h) {
        std::fill(h,h+(n<<1),0);
        for(int i=0;i!=n;i++) {
            for(int j=0;j!=n;j++) {
                h[i+j]=(h[i+j]+ull(f[i])*g[j])%mod;
            }
        }
    }
    inline void modulo(const uint &n,const uint &m,const uint *const f,const uint *const g,uint *const h) {
        std::copy(f,f+n,h);
        uint _m(m);
        while(_m!=0&&g[_m-1]==0) {
            --_m;
        }
        if(_m==0) {
            return;
        }
        const uint inv(power(g[_m-1],mod-2));
        for(uint i=n-1;i!=_m-2;i--) {
            const uint coef(ull(mod-h[i])*inv%mod);
            for(int j=0;j!=_m;j++) {
                h[i+j+1-_m]=(h[i+j+1-_m]+ull(coef)*g[j])%mod;
            }
        }
    }
    inline void power(const uint &n,const uint *const f,const uint *const g,uint *const h,const ull &m) {
        static uint t0[(N<<1)+5]{},t1[(N<<1)+5];
        std::copy(f,f+n,t0);
        std::fill(h,h+n,0);
        h[0]=1;
        for(ull i=m;i;i>>=1) {
            if(i&1) {
                multiply(n,h,t0,t1);
                modulo(n<<1,n,t1,g,h);
            }
            multiply(n,t0,t0,t1);
            modulo(n<<1,n,t1,g,t0);
        }
    }
}
uint stk[30],tag[30];
int main() {
    uint n;ull m;
    scanf("%u%llu",&n,&m);
    if((n&3)||(m&3)) {
        return puts("0"),0;
    }
    n>>=1,m>>=1;
    std::fill(id,id+(1<<n),-1u);
    uint tot(0);
    for(uint i=0;i!=1<<n;i++) {
        if(check(n,i)) {
            id[i]=tot++;
        }
    }
    matrix A(tot);
    for(uint i=0;i!=1<<n;i++) {
        if(id[i]==-1) {
            continue;
        }
        for(uint j=0;j!=1<<(n>>1)-1;j++) {
            dsu::init(n<<1);
            uint top(0);
            for(uint k=0;k!=n;k++) {
                if(i>>k&1) {
                    stk[top++]=k;
                }
                else {
                    dsu::merge(k,stk[--top]);
                }
            }
            dsu::merge(0,n);
            dsu::merge(n-1,(n<<1)-1);
            for(uint k=0;k!=(n>>1)-1;k++) {
                if(j>>k&1) {
                    dsu::merge(k<<1|1,(k<<1|1)+n);
                    dsu::merge(k+1<<1,(k+1<<1)+n);
                }
                else {
                    dsu::merge(k<<1|1,k+1<<1);
                    dsu::merge((k<<1|1)+n,(k+1<<1)+n);
                }
            }
            uint _i(0);
            std::fill(tag,tag+(n<<1),0);
            for(uint k=0;k!=n;k++) {
                if(!tag[dsu::getf(n+k)]) {
                    tag[dsu::getf(n+k)]=1,_i|=1<<k;
                }
            }
            uint c(0);
            for(uint k=0;k!=n;k++) {
                if(!tag[dsu::getf(k)]) {
                    tag[dsu::getf(k)]=1,++c;
                }
            }
            A.a[id[_i]][id[i]]+=1u<<c;
        }
    }
    matrix B(tot);
    for(uint i=0;i!=1<<n;i++) {
        if(id[i]==-1) {
            continue;
        }
        for(uint j=0;j!=1<<(n>>1);j++) {
            dsu::init(n<<1);
            uint top(0);
            for(uint k=0;k!=n;k++) {
                if(i>>k&1) {
                    stk[top++]=k;
                }
                else {
                    dsu::merge(k,stk[--top]);
                }
            }
            for(uint k=0;k!=n>>1;k++) {
                if(j>>k&1) {
                    dsu::merge(k<<1,(k<<1)+n);
                    dsu::merge(k<<1|1,(k<<1|1)+n);
                }
                else {
                    dsu::merge(k<<1,k<<1|1);
                    dsu::merge((k<<1)+n,(k<<1|1)+n);
                }
            }
            uint _i(0);
            std::fill(tag,tag+(n<<1),0);
            for(uint k=0;k!=n;k++) {
                if(!tag[dsu::getf(n+k)]) {
                    tag[dsu::getf(n+k)]=1,_i|=1<<k;
                }
            }
            uint c(0);
            for(uint k=0;k!=n;k++) {
                if(!tag[dsu::getf(k)]) {
                    tag[dsu::getf(k)]=1,++c;
                }
            }
            B.a[id[_i]][id[i]]+=1u<<c;
        }
    }
    matrix C(B.mul(A));
    vector S(tot);
    S.a[([&]()->uint {
        uint res(0);
        for(uint i=0;i!=n;i+=2) {
            res|=1u<<i;
        }
        return id[res];
    }())]=1;
    vector _S[(maxn<<1)+3]{};
    _S[0]=S;
    for(int i=0;i<=tot<<1;i++) {
        (_S[i+1]=_S[i]).lmul(C);
    }
    if((m>>1)-1<=(tot<<1)+1) {
        S=_S[(m>>1)-1];
    }
    else {
        vector R(tot);
        for(int i=0;i!=tot;i++) {
            R.a[i]=rand(1u,mod-1);
        }
        uint V[(maxn<<1)+5]{},W[(maxn<<1)+5]{};
        for(int i=1;i<=(tot<<1)+1;i++) {
            V[i]=R.dot(_S[i]);
        }
        const int len(linear::BM((tot<<1)+1,V,W));
        uint f[(maxn<<1)+5]{},g[(maxn<<1)+5]{},h[(maxn<<1)+5]{};
        f[1]=1;
        for(int i=1;i<=len;i++) {
            g[len-i]=minus(0,W[i]);
        }
        g[len]=1;
        poly::power(len+1,f,g,h,(m>>1)-1);
        S.clear();
        for(int i=0;i!=tot;i++) {
            for(int j=0;j<=len;j++) {
                S.a[i]=(S.a[i]+ull(_S[j].a[i])*h[j])%mod;
            }
        }
    }
    S.lmul(A);
    uint ans(0);
    for(uint i=0;i!=1<<n;i++) {
        if(id[i]==-1) {
            continue;
        }
        dsu::init(n);
        uint top(0);
        for(uint j=0;j!=n;j++) {
            if(i>>j&1) {
                stk[top++]=j;
            }
            else {
                dsu::merge(j,stk[--top]);
            }
        }
        for(uint j=0;j!=n>>1;j++) {
            dsu::merge(j<<1,j<<1|1);
        }
        std::fill(tag,tag+n,0);
        uint c(0);
        for(uint j=0;j!=n;j++) {
            if(!tag[dsu::getf(j)]) {
                tag[dsu::getf(j)]=1,++c;
            }
        }
        ans=(ans+(ull(S.a[id[i]])<<c))%mod;
    }
    printf("%u\n",ans);
    return 0;
}