/*


                          |~~~~~~~|
                          |       |
                          |       |
                          |       |
                          |       |
                          |       |
|~.\\\_\~~~~~~~~~~~~~~xx~~~         ~~~~~~~~~~~~~~~~~~~~~/_//;~|
|  \  o \_         ,XXXXX), поллард сука            _..-~ o /  |
|    ~~\  ~-.     XXXXX`)))),                 _.--~~   .-~~~   |
~~~~~~~`\   ~\~~~XXX' _/ ';))     |~~~~~~..-~     _.-~ ~~~~~~~
         `\   ~~--`_\~\, ;;;\)__.---.~~~      _.-~
           ~-.       `:;;/;; \          _..-~~
              ~-._      `''        /-~-~
                  `\            /  /
                    |         ,   | |
                     |  '        /  |
                      \/;           |
                       ;;           |
                       `;   .       |
                       |~~~-----.....|
                      | \             \
                     | /\~~--...__    |
                     (|  `\       __-\|
                     ||    \    /~    |
                     |)     \~-'      |
                      |      | \      '
                      |      |  \    :
                       \     |  |    |
                        |    )  (    )
                         \  /;  /\  |
                         |    |/   |
                         |    |   |
                          \  .'  ||
                          |  |  | |
                          (  | |  |
                          |   \ \ |
                          || o `.)|
                          |`\\\\) |
                          |       |
                          |       |
                          |       |
*/


#include <bits/stdc++.h>

#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize ("unroll-loops")

using namespace std;

#define TASK "tree"

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> par;
typedef unsigned int ui;

#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define X first
#define Y second
#define pw(x) (1ll << (x))
#define _ inline

mt19937 rnd(17);

const ll INF = 1e18;
const ll MOD = 786433;
const double EPS = 1e-12;
const double PI = acosl(-1);

const int L = 16;
const int N = pw(L);

const int ROOT = 3;

ll angles[N + 1];
int bitrev[N];

void init() {
    angles[0] = 1;
    for (int i = 1; i <= N; ++i) angles[i] = angles[i - 1] * ROOT % MOD;
    for (int i = 0; i < N; ++i) {
        int x = i;
        for (int j = 0; j < L; ++j) {
            bitrev[i] = (bitrev[i] << 1) | (x & 1);
            x >>= 1;
        }
    }
}

inline int revBit(int x, int len) {
    return bitrev[x] >> (L - len);
}

void fft(vector<ll>&a, bool inverse = false) {
    int n = a.size();
    int l = __builtin_ctz(n);
    for (int i = 0; i < n; ++i) {
        int j = revBit(i, l);
        if (i < j) {
            swap(a[i], a[j]);
        }
    }
    for (int len = 1; len < n; len *= 2) {
        for (int start = 0; start < n; start += 2 * len) {
            for (int i = 0; i < len; ++i) {
                ll x = a[start + i], y = a[start + len + i];
                int idx = N / 2 / len * i;
                ll w = angles[inverse ? N - idx : idx];
                w = w * y % MOD;
                a[start + i] = x + w;
                if (a[start + i] >= MOD) a[start + i] -= MOD;
                a[start + len + i] = x - w;
                if (a[start + len + i] < 0) a[start + len + i] += MOD;
            }
        }
    }

    if (inverse) {
        int rev_deg = 1;
        for (int i = 0; i < l; ++i) rev_deg = (rev_deg % 2) ? ((rev_deg + MOD) / 2) : (rev_deg / 2);
        for (auto& x : a) x = x * rev_deg % MOD;
    }
}

vector<ll> ar(N, 0), br(N, 0);

//dp[h][n] = 2 * sum(dp[h - 1][n - i - 1] * dp[h - 1][i]) + sum(dp[h - 2][n - i - 1] * dp[h - 1][i]) + sum(dp[h - 1][n - i - 1] * dp[h - 2][i]);

void f(ll k) {
    ar[1] = 1;
    br[0] = 1;
    fft(ar);
    fft(br);
    for (int kk = 0; kk < k; ++kk) {
        for (int i = 0; i < N; ++i) {
            br[i] = ((((2 * br[i] + ar[i]) % MOD) * ar[i] % MOD) % MOD * angles[i]) % MOD;
        }
        ar.swap(br);
    }
    fft(ar, true);
}

int source() {
    init();
    ll n, k;
    cin >> n >> k;
    f(k);
    cout << ar[n];
    return 0;
}

int main() {
#ifdef aokiga
    assert(freopen("input.txt", "r", stdin));
    assert(freopen("output.txt", "w", stdout));
#else
    //freopen(TASK".in", "r", stdin);
    //freopen(TASK".out", "w", stdout);
#endif

    srand(17);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    source();

#ifdef aokiga
    cerr << "TIME :: " << clock() * 1.0 / CLOCKS_PER_SEC;
#endif
    return 0;
}