Magic Digits

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
using namespace std;
#define mod 666013
int n, k;
long long powmod(long long a, long long b) {
    if (b == 0) {
        return 1;
    }
    if (b % 2 == 1) {
        return (a * powmod(a, b - 1)) % mod;
    }
    long long P = powmod(a, b / 2);
    return (P * P) % mod;
}
long long invers(long long a) {
    return powmod(a, mod - 2);
}
vector<long long> fact;
vector<long long> inv;
long long combs(long long n, long long k) {
    return (((fact[n] * inv[k]) % mod) * inv[n - k]) % mod;
}
void precompute(long long n) {
    fact = vector<long long>(n + 1);
    fact[0] = 1;
    for (long long i = 1; i <= n; ++i) {
        fact[i] = fact[i - 1ll] * i;
        fact[i] %= mod;
    }
    inv = vector<long long>(n + 1);
    inv[n] = invers(fact[n]);
    for (long long i = n - 1; i >= 0; --i) {
        inv[i] = ((i + 1ll) * inv[i + 1ll]) % mod;
    }
}
long long solve(long long min, long long max) {
    vector<vector<vector<vector<long long>>>> dp
    (10, vector<vector<vector<long long>>>
        (n + 1ll, vector<vector<long long>>(2, vector<long long>(2))));
    for (long long i = 0; i <= 9; ++i) {
        dp[i][0][0][0] = 1;
    }
    for (long long i = 1; i <= 9; ++i) {
        for (long long j = 1; j <= n; ++j) {
            dp[i][j][0][1] = dp[i - 1][j][0][1];
            dp[i][j][1][0] = dp[i - 1][j][1][0];
            dp[i][j][0][0] = dp[i - 1][j][0][0];
            dp[i][j][1][1] = dp[i - 1][j][1][1];
            for (long long t = min + 1; t <= j && t < max; ++t) {
                dp[i][j][0][1] += combs(j, t) * dp[i - 1][j - t][0][1];
                dp[i][j][0][1] %= mod;
                dp[i][j][1][0] += combs(j, t) * dp[i - 1][j - t][1][0];
                dp[i][j][1][0] %= mod;
                dp[i][j][0][0] += combs(j, t) * dp[i - 1][j - t][0][0];
                dp[i][j][0][0] %= mod;
                dp[i][j][1][1] += combs(j, t) * dp[i - 1][j - t][1][1];
                dp[i][j][1][1] %= mod;
            }
            if (min == max && j >= min) {
                dp[i][j][1][1] += combs(j, min) *
                    (dp[i - 1][j - min][1][1] + dp[i - 1][j - min][0][0]
                        + dp[i - 1][j - min][1][0] + dp[i - 1][j - min][0][1]);
                dp[i][j][1][1] %= mod;
            }
            else {
                if (j >= min) {
                    dp[i][j][1][0] += combs(j, min) * (dp[i - 1][j - min][1][0] + dp[i - 1][j - min][0][0]);
                    dp[i][j][1][0] %= mod;
                    dp[i][j][1][1] += combs(j, min) * (dp[i - 1][j - min][1][1] + dp[i - 1][j - min][0][1]);
                    dp[i][j][1][1] %= mod;
                }
                if (j >= max) {
                    dp[i][j][0][1] += combs(j, max) * (dp[i - 1][j - max][0][1] + dp[i - 1][j - max][0][0]);
                    dp[i][j][0][1] %= mod;
                    dp[i][j][1][1] += combs(j, max) * (dp[i - 1][j - max][1][1] + dp[i - 1][j - max][1][0]);
                    dp[i][j][1][1] %= mod;
                }
            }
        }
    }
    return dp[9][n][1][1];
}
int main() {
    cin >> n >> k;
    if (k > n) {
        if (k == 2 * n) {
            cout << 9;
        }
        else {
            cout << 0;
        }
        return 0;
    }
    precompute(n);
    long long ans = 0;
    long long p1 = 1, p2 = k - 1ll;
    while (p1 <= p2) {
        ans += solve(p1, p2);
        ans %= mod;
        p1++;
        p2--;
    }
    cout << ans;
}