// CODING BEAST
/*******************************************************************************************************************************************************/
#include<bits/stdc++.h>
using namespace std;
#define sum(a)     ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a)    (*min_element((a).begin(), (a).end()))
#define maxe(a)    (*max_element((a).begin(), (a).end()))
#define mini(a)    ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a)    ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a * b) / gcd(a, b)
#define Precision(a) cout << fixed << setprecision(a)
using ll = long long;
ll inf = 1e18;
using vb = vector<bool>; using vc = vector<char>; using vd = vector<double>; using vi = vector<int>; using vvi = vector<vi>;
using vll = vector<ll>; using vvll = vector<vll>; using pi = pair<int, int>; using pll = pair<ll, ll>;
#define endl "\n"
#define pb push_back
#define mp make_pair
#define rep(i,n) for(ll i = 0; i < n; i++)
#define repc(i,a,n) for(ll i=a;i<n;i++)
#define all(a) a.begin(),a.end()
#define pow2(x) (1ll<<(x))
#define Blazing_fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define trav(a,v) for(auto &a:v)
// int a[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
// int b[8] = { -1, 0, 1, -1, 1, -1, 0, 1};
ll mod = 1e9;
// ll modx(ll a, ll b) {
//     return (((a % b) + b) % b);
// }
// inline ll power(ll x, ll y)
// {
//     ll temp;
//     if ( y == 0)
//         return 1;
//     temp = power(x, y / 2) ;
//     if (y % 2 == 0)
//         return (temp * temp) % mod ;
//     else
//         return (((x * temp) % mod) * temp) % mod ;
// }
// bool cmp(pll & a, pll & b) {
//     if (a.first == b.first) {
//         return (a.second < b.second);
//     }
//     else {
//         return (a.first > b.first);
//     }
// }

// ll fact(ll n)
// {
//     ll res = 1;
//     for (ll i = 2; i <= n; i++)
//         res = (res * i) % mod ;
//     return res;
// }
// ll inv(ll a) {
//     return power(a, mod - 2);
// }
// ll ncr(ll n, ll r)
// {
//     ll x = fact(n);
//     ll y = ((inv(fact(r)) % mod) * (inv(fact(n - r)))) % mod;
//     return ((x % mod) * y) % mod;
// }
// bool isprime(ll n) {
//     if (n <= 1) return false;
//     if (n <= 3) return true;
//     if ((n % 2 == 0) || (n % 3 == 0)) return false;
//     for (ll i = 5; i * i <= n; i = i + 6)
//         if ((n % i == 0) || (n % (i + 2) == 0)) return false;

//     return true;
// }
/*********************************************************************************************************************************************************/
//whenever given equality try to rewrite it
//matrix remember about even odd or modularity

void solve() {
    ll n, k;
    cin >> n >> k;
    ll ans = 0;
    for (ll i = 1; i <= n; i++) {
        ll p = i * 100;
        for (ll j = 1; j <= k; j++) {
            ans += p + j;
        }
    }
    cout << ans << endl;
}



signed main() {
    Blazing_fast
    ll t = 1;
    // ll t; cin >> t;
    while (t--) {
        solve();
    }
}

#include <bits/stdc++.h>
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
using namespace std;

typedef long long ll;
typedef unsigned long long llu;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<int, pii> piii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<int, ll> pil;
typedef pair<string, int> psi;
typedef pair<char, int> pci;
typedef pair<int, char> pic;
const int MOD = 998244353;
const long double PI = 3.141592653589793238462643383279502884197;

ll fac[51] = {1}, inv[1] = {1};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll mp(ll a,ll b){ll ret=1;while(b){if(b&1)ret=ret*a%MOD;a=a*a%MOD;b>>=1;}return ret;}
ll cmb(ll r, ll c) {return (c>r||c<0) ? 0:fac[r] * inv[c] % MOD * inv[r - c] % MOD;}

int dp[3001][3001];
int go(int n, int k) {
    if (k > n) return 0;
    if (k == 0) return n == 0;
    if (dp[n][k] != -1) return dp[n][k];

    ll ret = 0;
    ret += go(n - 1, k - 1);
    ret += go(n, k * 2);
    return dp[n][k] = ret % MOD;
}

int main() {
    memset(dp, -1, sizeof(dp));
    int n, k;
    scanf("%d %d", &n, &k);
    printf("%d", go(n, k));
}


// author: rdd6584
