RT,

#include <cstring>
#include <iostream>
#include <algorithm>

#define endl '\n'
#define int long long
#define inf 998244353
#define lnf 0x3f3f3f3f3f3f3f3f

#pragma GCC optimize (1)
#pragma GCC optimize (2)
#pragma GCC optimize (3)
#pragma GCC optimize ("Os")
#pragma GCC optimize ("Ofast")

const bool Debug = false;

//#define Debug true

using namespace std;

namespace WTH {
	template <typename _Tp, size_t n, size_t m>
		class Matrix {
			private :
			
			protected :
			
			public :
				_Tp _Mp[n][m];
				
				void Reset () {
					memset (_Mp, 0, sizeof (_Mp));
				}
				
				bool Set () {
					if (n != m) {
						return 0;
					}
					
					Reset ();
					
					for (register int i = 0; i < n; ++ i) {
						_Mp[i][i] = 1;
					}
					
					return 1;
				}
				
				template <size_t M>
					Matrix <_Tp, n, M> operator * (const Matrix <_Tp, m, M> _Oper) {
						Matrix <_Tp, n, M> _Rtrn;
						_Rtrn.Reset ();
						
						for (register int k = 0; k < m; ++ k) {
							for (register int i = 0; i < n; ++ i) {
								for (register int j = 0; j < M; ++ j) {
									_Rtrn._Mp[i][j] += (_Mp[i][k] * _Oper._Mp[k][j]) % inf;
									_Rtrn._Mp[i][j] %= inf;
								}
							}
						}
						
						return _Rtrn;
					}
				
				Matrix <_Tp, n, m> operator ^ (int _Oper) {
					Matrix <_Tp, n, m> _Ans;
					_Ans.Set ();
					
					if (n != m) {
						return _Ans;
					}
					
					while (_Oper) {
						if (_Oper & 1) {
							_Ans = _Ans * (* this);
						}
						
						(* this) = (* this) * (* this);
						_Oper >>= 1;
					}
					
					return (* this);
				}
				
				void operator ^= (int _Oper) {
					(* this) = (* this) ^ _Oper;
				}
				
				void debug () {
					for (register int i = 0; i < n; ++ i) {
						for (register int j = 0; j < m; ++ j) {
							cout << _Mp[i][j] << ' ';
						}
						
						cout << endl;
					}
				}
			
		} ;
	
	const int N = (1 << 6) + 5;
	
	int h, w;
	int h_2, f[N];
	int _Ans, _;
	Matrix <int, N, N> _Cmpt;
	
	void DFS (int id, int lst, int nw) {
		if (! (h - id)) {
			if (! lst) {
				++ f[nw];
			}
			
			return ;
		}
		
		if (! (lst - 1)) {
			DFS (id + 1, 0, ((nw << 1) | 1));
		} else {
			DFS (id + 1, 0, (nw << 1));
			DFS (id + 1, 0, ((nw << 1) | 1));
			DFS (id + 1, 1, ((nw << 1) | 1));
		}
	}
	
	namespace IO {
		void Input () {
			cin >> h >> w;
		}

		void Output () {
			cout << _Ans % inf << endl;
		}
	}

	void Init () {
		_Ans = 0;
	}

	void Main () {
		IO :: Input ();
		
		h_2 = (1 << h);
		DFS (0, 0, 0);
		
		for (register int i = 0; i < h_2; ++ i) {
			_ = i ^ (h_2 - 1);
			
			for (register int j = 0; j < h_2; ++ j) {
				if ((_ & j) == _) {
					_Cmpt._Mp[i][j] = f[i & j];
				}
			}
		}
		
		if (Debug) {
			_Cmpt.debug ();
		}
		
		_Cmpt ^= (w - 2);
		
		if (Debug) {
			_Cmpt.debug ();
		}
		
		for (register int i = 0; i < h_2; ++ i) {
			_Ans = (_Ans + f[i] * _Cmpt._Mp[i][h_2 - 1] % inf) % inf;
		}
		
		IO :: Output ();
	}
}

signed main () {
	ios :: sync_with_stdio (Debug);
	cin.tie (0);
	cout.tie (0);

	int T = 1;
	//cin >> T;

	while (T --) {
		WTH :: Init ();
		WTH :: Main ();
	}

	return 0;
}