考虑对于两个相邻的元素，必定只有一个大于等于(lceilfrac m2 ceil)，那么对于所有大于等于(lceilfrac m2 ceil)的元素，我们将他减去(lceilfrac m2 ceil)，则变成了一个子问题，相邻两个元素的和不能超过(lfloorfrac m2 floor)。
考虑如何通过子问题答案推出答案，先不考虑首尾相接的情况，将大于等于(lceilfrac m2 ceil)的设为1，其余设为0，则必定是若干个长度为奇数的0101010...10这样的段落拼接起来，两边可能会有长度为偶数的1010...10和0101...01这样的段拼在左右。
但是很快会发现这样存在问题，那就是当(m)为奇数时，有可能会存在(lfloorfrac m2 floor)这样的单个元素组成一个0跟其他的奇数段拼起来，特殊处理即可。
则我们考虑设长度为奇数的段的生成函数为(A)，长度为偶数的段的生成函数为(B)，整体的生成函数为(F)则对于(m)为偶数的情况，有：
注意由于咱们不考虑首尾相接，则可能会有一整段是10101...01的情况，因此要在后面在加上一个(A)。
m为奇数的情况，则：
接下来就是如何算答案。
可以发现对于(n)为奇数的情况，要么就是首尾都是一段奇数段，要么就是首尾拼起来成为了一段奇数段，则本质上相当于一个奇数段拼上了一个偶数段，因为(n)为奇数的情况必定存在两个连续的0。
对于(n)为偶数的情况，则不一定存在两个连续的(0)，有可能会有01010101...01这种情况，但倘若我们不断把大于等于(lceilfrac m2 ceil)的元素减去(lceilfrac m2 ceil)，则最后要么全部变成了(0)，要么必定存在一个情况存在两个连续的(0)，则我们对于偶数的情况，在每一层递归都算一遍即可。
复杂度是(O(nlog nlog m))，但好像被锤烂了。
Elegia的高级做法，了解一下：
We can solve F in (O(nlog n)), here is a sketch:
When n is even, a1<m−a2>a3<⋯<m−an>a1. So we need to count the sequences 0≤bi≤m where b1
When n is odd, the pattern should be a ring with xy…yx where x≤m2 and y>m2. You can let x←⌈m/2⌉−x and then it becomes a <><>⋯ again.
#include <bits/stdc++.h>
#define I inline
#define fi first
#define se second
#define LL long long
#define mp make_pair
#define reg register int
#define pii pair<int,int>
#define fo(i, a, b) for(int i = a; i <= b; i++)
#define fd(i, a, b) for(reg i = a; i >= b; i--)
#define ULL unsigned long long
#define cr const reg&
using namespace std;
const int inf = 2147483647;
const int mod = 998244353;
const int N = 1e6 + 1;
I int _max(cr x, cr y) {return x > y ? x : y;}
I int _min(cr x, cr y) {return x < y ? x : y;}
I LL read() {
LL x = 0, f = 1; char ch = getchar();
while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
while(ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
I void ptt(LL x) {if(x >= 10) ptt(x / 10); putchar(x % 10 + '0');}
I void put(LL x) {x < 0 ? putchar('-'), ptt(-x) : ptt(x);}
I void pr1(LL x) {put(x), putchar(' ');}
I void pr2(LL x) {put(x), puts("");}
I int pow_mod(reg a, reg k) {reg ans = 1; for(; k; k >>= 1, a = (LL)a * a % mod) if(k & 1) ans = (LL)ans * a % mod; return ans;}
int n, m, ans;
namespace Poly {
int w[131073], R[131073]; ULL p[131073];
int a[131073], b[131073], h[131073], d0[131073], d1[131073];
I int Pre(cr n) {
reg len = 1; for(; len <= n; len <<= 1);
for(reg i = 1; i < (len << 1); i <<= 1) {
reg s = 1, wn = pow_mod(3, (mod - 1) / (i << 1));
fo(j, 0, i - 1) w[i + j] = s, s = (LL)s * wn % mod;
} return len;
}
I int gao(int x) {return x < 0 ? x + mod : x;}
I void DFT(int y[], cr len) {
fo(i, 0, len - 1) p[R[i]] = gao(y[i]);
int b;
for(reg i = 1; i < len; i <<= 1) for(reg j = 0; j < len; j += i << 1)
fo(k, 0, i - 1) b = p[i + j + k] * w[i + k] % mod, p[i + j + k] = p[j + k] + mod - b, p[j + k] += b;
fo(i, 0, len - 1) y[i] = p[i] % mod;
}
I void IDFT(int y[], cr len) {
reverse(y + 1, y + len); DFT(y, len); reg hh = pow_mod(len, mod - 2);
fo(i, 0, len - 1) y[i] = (LL)y[i] * hh % mod;
}
I void clear(int a[], cr len) {memset(a + len, 0, sizeof(a[0]) * len);}
I void clear(int a[], cr s, cr t) {if(s >= t) return ; memset(a + s, 0, sizeof(a[0]) * (t - s));}
I void cpy(int a[], int b[], cr len) {memcpy(a, b, sizeof(a[0]) * len), memset(a + len, 0, sizeof(a[0]) * len);}
I void getinv(int a[], int b[], cr len) {
if(len == 1) {b[0] = pow_mod(a[0], mod - 2), b[1] = 0; return ;}
getinv(a, b, len >> 1); cpy(h, a, len), clear(b, len);
fo(i, 0, (len << 1) - 1) R[i] = (R[i >> 1] >> 1) | ((i & 1) ? len : 0);
DFT(h, len << 1), DFT(b, len << 1);
fo(i, 0, (len << 1) - 1) b[i] = (2 - (LL)b[i] * h[i]) % mod * b[i] % mod;
IDFT(b, len << 1); clear(b, len);
}
I void solve(cr v, cr len) {
if(v == 1) {
fo(i, 0, len - 1) a[i] = 1;
ans = 1;
return ;
} solve(v >> 1, len);
memset(d0, 0, sizeof(int) * (len << 1));
memset(d1, 0, sizeof(int) * (len << 1));
fo(i, 0, len - 1) (i & 1 ? d1 : d0)[i] = a[i];
if(v & 1) d1[1]++, d1[1] = d1[1] >= mod ? d1[1] - mod : d1[1];
memset(a, 0, sizeof(int) * (len << 1));
fo(i, 0, len - 1) a[i] = d1[i] ? mod - d1[i] : 0;
a[0]++, a[0] = a[0] >= mod ? a[0] - mod : a[0];
getinv(a, b, len);
if(v == m || !(n & 1)) {
reg sum = 0;
for(int i = 1; i <= n; i += 2) sum = (sum + (LL)b[n - i] * d1[i] % mod * i) % mod;
if(!(n & 1)) ans = (2LL * ans + sum) % mod;
else ans = sum;
if(v == m) return ;
} DFT(d0, len << 1);
fo(i, 0, (len << 1) - 1) d0[i] = (LL)d0[i] * d0[i] % mod;
IDFT(d0, len << 1); clear(d0, len);
DFT(d0, len << 1), DFT(b, len << 1);
fo(i, 0, (len << 1) - 1) a[i] = (LL)b[i] * d0[i] % mod;
IDFT(a, len << 1);
fo(i, 0, len - 1) a[i] = a[i] + d1[i], a[i] = a[i] >= mod ? a[i] - mod : a[i];
if(v & 1) a[1] ? a[1]-- : a[1] = mod - 1;
}
}
int main() {
n = read(), m = read();
reg len = Poly::Pre(n);
Poly:: solve(m, len);
pr2(ans < 0 ? ans + mod : ans);
return 0;
}