#pragma GCC optimize("Ofast,no-stack-protector,unroll-all-loops,unroll-loops")
#pragma GCC target("abm,mmx,sse,sse2,sse3,ssse3,sse4a,popcnt,tune=native")
#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <random>

using namespace std;

#define int int64_t

const long long mod = 786433;
const int root = 5;

long long pow_(long long a, long long b) {
    if (b == 0)
        return 1;
    long long p = pow_(a, b / 2);
    if (b % 2 == 0)
        return p * p % mod;
    else
        return (p * p % mod) * a % mod;
}

int rev(int num, int len) {
    int res = 0;
    for (int i = 0; i < len; i++)
        if (num & (1 << i))
            res |= 1 << (len - i - 1);
    return res;
}

void fft(vector <int> &a, int n, bool inv) {
    int log_ = 0;
    while ((1 << log_) < n)
        ++log_;
    for (int i = 0; i < n; i++)
        if (i < rev(i, log_))
            swap(a[i], a[rev(i, log_)]);
    for (int len = 2; len <= n; len <<= 1) {
        long long wlen = pow_(root, (mod - 1) / len);
        for (int j = 0; j < n; j += len) {
            long long w = 1;
            for (int k = j; k < j + len / 2; k++) {
                long long u = a[k];
                long long v = w * a[k + len / 2] % mod;
                a[k] = (u + v) % mod;
                a[k + len / 2] = (u - v + mod) % mod;
                w = w * wlen % mod;
            }
        }
    }
    if (inv == true) {
        for (int i = 0; i < n; i++)
            if (i + 1 < n - 1 - i)
                swap(a[i + 1], a[n - 1 - i]);
        long long kek = pow_(n, mod - 2);
        for (int i = 0; i < n; i++)
            a[i] = a[i] * kek % mod;
    }
}

vector <int> operator *(vector <int> a, vector <int> b) {
    int n = 1;
    while (n < (int)a.size() + (int)b.size())
        n <<= 1;
    a.resize(n);
    b.resize(n);
    fft(a, n, false);
    fft(b, n, false);
    vector <int> c(n);
    for (int i = 0; i < n; i++)
        c[i] = a[i] * b[i] % mod;
    fft(c, n, true);
    while (c.size() > 1 && c.back() == 0)
        c.pop_back();
    return c;
}

vector <int> operator *(long long k, const vector <int> &a) {
    vector <int> b((int)a.size());
    for (int i = 0; i < (int)b.size(); i++)
        b[i] = ((long long)a[i] * k) % mod;
    return b;
}

vector <int> operator +(vector <int> a, vector <int> b) {
    int n = max((int)a.size(), (int)b.size());
    a.resize(n);
    b.resize(n);
    vector <int> c(n);
    for (int i = 0; i < n; i++)
        c[i] = (a[i] + b[i]) % mod;
    return c;
}


int32_t main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n, h;
    cin >> n >> h;
    vector <int> h_2 = {1};
    vector <int> h_1 = {0, 1};
    vector <int> result = h_1;

    for (int t = 1; t <= h; t++) {
        result = (h_1 * h_1 + 2 * h_2 * h_1);
        result.push_back(0);
        for (int i = (int)result.size() - 1; i >= 1; i--)
            result[i] = result[i - 1];
        result[0] = 0;
        h_2 = h_1;
        h_1 = result;
    }
    cout << result[n] << endl;
    return 0;
}