#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define ll long long
#define RCL(a,b,c,d) memset(a,b,sizeof(c)*(d))
#define tomin(a,...) ((a)=min({(a),__VA_ARGS__}))
#define tomax(a,...) ((a)=max({(a),__VA_ARGS__}))
#define FOR(i,a,b) for(int i(a); i<=(int)(b); ++i)
#define DOR(i,a,b) for(int i(a); i>=(int)(b); --i)
#define EDGE(g,i,x,y) for(int i(g.h[x]),y(g[i].v); ~i; y=g[i=g[i].nxt].v)
using namespace std;
constexpr int lN(30),lV(lN+2);

namespace IOEstream {
#define isdigit(ch) ('0'<=(ch)&&(ch)<='9')
#define DE(...) E(#__VA_ARGS__,__VA_ARGS__)

	struct Istream {
		char getc() {
			return getchar();
		}
		template<class T>void operator ()(T &x) {
			static bool sign(0);
			static char ch(0);
			sign=0,x=0;
			while(ch=getc(),!isdigit(ch))if(ch=='-')sign=1;
			do x=(x<<3)+(x<<1)+(ch^48);
			while(ch=getc(),isdigit(ch));
			if(sign)x=-x;
		}
		template<class T,class...Types>void operator ()(T &x,Types &...args) {
			return (*this)(x),(*this)(args...);
		}
	} I;

	struct Ostream {
		void putc(char c) {
			putchar(c);
		}
		template<class T>void operator ()(T x,const char lst='\n') {
			static int top(0);
			static char st[50];
			if(x<0)putc('-'),x=-x;
			do st[++top]=(x%10)^48,x/=10;
			while(x);
			while(top)putc(st[top--]);
			putc(lst);
		}
		template<class T,class...Types>void operator ()(const T x,const char lst='\n',const Types ...args) {
			return (*this)(x,lst),(*this)(args...);
		}
	} O;

	struct Estream {
		template<class T>void operator ()(const char *fmt,T x) {
			cerr<<fmt<<':'<<x<<".\n";
		}
		template<class T,class...Types>void operator ()(const char *fmt,const T x,const Types ...args) {
			while(*fmt^',')cerr<<*fmt++;
			return cerr<<':'<<x<<", ",(*this)(++fmt,args...);
		}
	} E;

} using namespace IOEstream;

namespace Modular {
#define Mod 998244353
	template<class T1,class T2>constexpr auto add(const T1 a, const T2 b) {
		return a+b>=Mod?a+b-Mod:a+b;
	}

	template<class T1,class T2>constexpr auto mul(const T1 a,const T2 b) {
		return (ll)a*b%Mod;
	}

	template<class T,class...Types>constexpr auto add(const T a,const Types...args) {
		return add(a,add(args...));
	}

	template<class T,class...Types>constexpr auto mul(const T a,const Types...args) {
		return mul(a,mul(args...));
	}

	template<class T1,class T2>T1 &toadd(T1 &a,const T2 b) {
		return a=add(a,b);
	}

	template<class T1,class T2>T1 &tomul(T1 &a,const T2 b) {
		return a=mul(a,b);
	}

	template<class T0,class T,class...Types>T0 &toadd(T0 &a,const T b,const Types...args) {
		return toadd(a,b),toadd(a,args...);
	}

	template<class T0,class T,class...Types>T0 &tomul(T0 &a,const T b,const Types...args) {
		return tomul(a,b),tomul(a,args...);
	}

} using namespace Modular;

int n,m,w;
int f[2];
struct Mat {
	int n,m;
	int a[3][3];
	int *operator [](int i) {
		return a[i];
	}
	Mat(int n=0,int m=0,bool unit=0):n(n),m(m) {
		RCL(a,0,a,1),a[0][0]=a[1][1]=a[2][2]=unit;
	}
	friend Mat operator *(Mat A,Mat B) {
		Mat C(A.n,B.m);
		FOR(k,0,A.m-1)FOR(i,0,C.n-1)FOR(j,0,C.m-1)toadd(C[i][j],mul(A[i][k],B[k][j]));
		return C;
	}
	friend Mat operator ^(Mat A,int b) {
		Mat res(A.n,A.n,1);
		for(; b; b>>=1,A=A*A)if(b&1)res=res*A;
		return res;
	}
} A,B;

int main() {
	I(n,m),A=Mat(1,3),B=Mat(3,3);
	A[0][0]=0,A[0][1]=2,A[0][2]=3;
	B[0][0]=0,B[0][1]=0,B[0][2]=1;
	B[1][0]=1,B[1][1]=0,B[1][2]=1;
	B[2][0]=0,B[2][1]=1,B[2][2]=0;
	w=(A*(B^(n-3)))[0][2],f[0]=1;
	/**/
//	g[1]=0,g[2]=2,g[3]=3;
//	FOR(i,4,n)g[i]=add(g[i-2],g[i-3]);
//	w=g[n];
	/**/
	FOR(i,0,lN) {
		bool typ(m>>i&1);
		toadd(tomul(f[typ^1],w),f[typ]);
	}
	O(f[0],'\n');
	return 0;
}
/*
1. m&1<<i == 0
	f_{i+1,0} = f_{i,0}
	f_{i+1,1} = w * f_{i,1} + f_{i,0}
2. m&1<<i == 1
	f_{i+1,0} = w * f_{i,0} + f_{i,1}
	f_{i+1,1} = f_{i,1}
*/
/*
[f_1,f_2,f_3] = {0,2,3}
[f_2,f_3,f_4] = [f_1,f_2,f_3] * 
\begin{bmatrix}
0 0 1
1 0 1
0 1 0
\end{bmatrix}
*/