#include <bits/stdc++.h>
using namespace std;

const int MOD = 998244353;

int add(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

int sub(int a, int b) {
    return a >= b ? a - b : a + MOD - b;
}

int mul(int a, int b) {
    return (1ll * a * b) % MOD;
}

int pw(int x, int n) {
    int res = 1;
    while (n) {
        if (n % 2 == 0) {
            x = mul(x, x);
            n /= 2;
        } else {
            res = mul(res, x);
            --n;
        }
    }
    return res;
}

const int MAXN = 7;
vector<int> g[MAXN * 4];

void clear_g(int n) {
    for (int i = 0; i < 2 * n; ++i) {
        g[i].clear();
    }
}

void add_start(const string& s) {
    int n = s.size();
    vector<int> st;
    for (int i = 0; i < n; ++i) {
        if (s[i] == '(') {
            st.push_back(i);
        } else {
            g[st.back()].push_back(i);
            g[i].push_back(st.back());
            st.pop_back();
        }
    }
}

void add_square(int n, int i, int c) {
    if (c == 0) {
        g[i].push_back(i + 1);
        g[i + 1].push_back(i);
        g[i + n].push_back(i + 1 + n);
        g[i + 1 + n].push_back(i + n);
    } else {
        g[i].push_back(i + n);
        g[i + n].push_back(i);
        g[i + 1].push_back(i + 1 + n);
        g[i + 1 + n].push_back(i + 1);
    }
}

pair<string, int> get(int n) {
    vector<int> used(2 * n);
    string s;
    for (int i = n; i < 2 * n; ++i) {
        if (used[i]) {
            s.push_back(')');
            continue;
        }
        s.push_back('(');
        int j = i;
        while (j != -1) {
            used[j] = 1;
            int nj = -1;
            for (int j1 : g[j]) {
                if (!used[j1]) {
                    nj = j1;
                    break;
                }
            }
            j = nj;
        }
    }
    int cnt = 1;
    for (int i = 0; i < n; ++i) {
        if (used[i]) {
            continue;
        }
        int j = i;
        while (j != -1) {
            used[j] = 1;
            int nj = -1;
            for (int j1 : g[j]) {
                if (!used[j1]) {
                    nj = j1;
                    break;
                }
            }
            j = nj;
        }
        cnt *= 2;
    }
    return {s, cnt};
}

vector<string> all;

void gen(string cur, int bal, int n) {
    if ((int)cur.size() == n) {
        if (bal == 0) {
            all.push_back(cur);
        }
        return;
    }
    if (bal > 0) {
        cur.push_back(')');
        gen(cur, bal - 1, n);
        cur.pop_back();
    }
    if (bal + 1 <= n - (int)cur.size() - 1) {
        cur.push_back('(');
        gen(cur, bal + 1, n);
        cur.pop_back();
    }
}

vector<vector<int>> operator*(const vector<vector<int>>& a, const vector<vector<int>>& b) {
    int n = a.size();
    int m = a[0].size();
    int k = b[0].size();
    vector<vector<int>> c(n, vector<int>(k, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < k; ++j) {
            for (int p = 0; p < m; ++p) {
                c[i][j] = add(c[i][j], mul(a[i][p], b[p][j]));
            }
        }
    }
    return c;
}

vector<int> operator*(const vector<int>& a, const vector<int>& b) {
    vector<int> c(a.size() + b.size() - 1);
    for (int i = 0; i < (int)a.size(); ++i) {
        for (int j = 0; j < (int)b.size(); ++j) {
            c[i + j] = add(c[i + j], mul(a[i], b[j]));
        }
    }
    return c;
}

void cut(vector<int>& a, const vector<int>& p) {
    int n = p.size();
    while (a.size() > p.size()) {
        for (int i = 0; i < n; ++i) {
            a[a.size() - n - 1 + i] = add(a[a.size() - n - 1 + i], mul(a.back(), p[i]));
        }
        a.pop_back();
    }
}

vector<int> binpow(vector<int> x, int64_t m, const vector<int>& p) {
    vector<int> res = {1};
    while (m) {
        if (m % 2 == 0) {
            x = x * x;
            cut(x, p);
            m /= 2;
        } else {
            res = res * x;
            cut(res, p);
            --m;
        }
    }
    return res;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int h;
    int64_t w;
    cin >> h >> w;
    if (h % 4 != 0 || w % 4 != 0) {
        cout << "0\n";
        return 0;
    }

    h /= 2; w /= 2;
    gen("", 0, h);
    map<string, int> id;
    int C = all.size();
    for (int i = 0; i < C; ++i) {
        id[all[i]] = i;
    }

    vector<vector<int>> s(C, vector<int>(1, 0));
    vector<vector<int>> PtB(C, vector<int>(C, 0));
    vector<vector<int>> BtP(C, vector<int>(C, 0));
    vector<vector<int>> t(1, vector<int>(C, 0));

    s[0][0] = 1;
    for (int i = 0; i < C; ++i) {
        clear_g(h);
        add_start(all[i]);
        for (int j = 0; j < h; j += 2) {
            add_square(h, j, 0);
        }
        auto res = get(h);
        t[0][i] = res.second;
    }

    for (int i = 0; i < C; ++i) {
        for (int mask = 0; mask < (1 << (h / 2)); ++mask) {
            clear_g(h);
            add_start(all[i]);
            for (int j = 0; j < h; j += 2) {
                if (mask & (1 << (j / 2))) {
                    add_square(h, j, 1);
                } else {
                    add_square(h, j, 0);
                }
            }
            auto res = get(h);
            BtP[id[res.first]][i] = add(BtP[id[res.first]][i], res.second);
        }
    }

    for (int i = 0; i < C; ++i) {
        for (int mask = 0; mask < (1 << (h / 2 - 1)); ++mask) {
            clear_g(h);
            add_start(all[i]);
            g[0].push_back(h);
            g[h].push_back(0);
            g[h - 1].push_back(2 * h - 1);
            g[2 * h - 1].push_back(h - 1);
            for (int j = 1; j + 1 < h; j += 2) {
                if (mask & (1 << (j / 2))) {
                    add_square(h, j, 1);
                } else {
                    add_square(h, j, 0);
                }
            }
            auto res = get(h);
            /// cerr << all[i] << "->" << res.first << " " << res.second << endl;
            PtB[id[res.first]][i] = add(PtB[id[res.first]][i], res.second);
        }
    }

    t = t * PtB;
    vector<vector<int>> A = BtP * PtB;
    int64_t m = w / 2 - 1;
    /// t*A^m*s

    vector<int> val(2 * C);
    for (int i = 0; i < 2 * C; ++i) {
        val[i] = (t * s)[0][0];
        s = A * s;
    }

    vector<vector<int>> eq(C, vector<int>(C + 1, 0));
    for (int i = 0; i < C; ++i) {
        for (int k = 0; k <= C; ++k) {
            eq[i][k] = val[i + k];
        }
    }
    int col = 0;
    vector<array<int, 2>> var;
    for (int i = 0; i < C && col < C; ++i) {
        int id = -1;
        for (int j = i; j < C; ++j) {
            if (eq[j][i] != 0) {
                id = j;
                break;
            }
        }
        if (id == -1) {
            ++col;
            --i;
            continue;
        }
        swap(eq[i], eq[id]);
        var.push_back({col, i});
        int anti = pw(eq[i][i], MOD - 2);
        for (int j = 0; j <= C; ++j) {
            eq[i][j] = mul(eq[i][j], anti);
        }
        for (int j = 0; j < C; ++j) {
            if (j == i) continue;
            int val = eq[j][i];
            for (int k = 0; k <= C; ++k) {
                eq[j][k] = sub(eq[j][k], mul(val, eq[i][k]));
            }
        }
        ++col;
    }
    vector<int> p(C);
    for (auto elem : var) {
        p[elem[0]] = eq[elem[1]][C];
    }

    vector<int> x = {0, 1};
    x = binpow(x, m, p);
    int ans = 0;
    for (int i = 0; i < C; ++i) {
        ans = add(ans, mul(x[i], val[i]));
    }
    cout << ans << "\n";

    return 0;
}