#include <bits/stdc++.h>

 const int MO = ;

 const int N = ;

 int n, K, fac[N], inv[N], invn[N];

 int f[][N], g[][N], A[N * ], B[N * ], r[N * ];

 inline int C(int n, int m) {

     if(n <  || m <  || n < m) return ;

     return 1ll * fac[n] * invn[m] % MO * invn[n - m] % MO;

 }

 inline int qpow(int a, int b) {

     int ans = ;

     while(b) {

         if(b & ) ans = 1ll * ans * a % MO;

         a = 1ll * a * a % MO;

         b = b >> ;

     }

     return ans;

 }

 inline int Inv(int x) {

     return qpow(x, MO - );

 }

 inline void prework(int n) {

     static int R = ;

     if(R == n) return;

     R = n;

     int lm = ;

     while(( << lm) < n) lm++;

     for(int i = ; i < n; i++) {

         r[i] = (r[i >> ] >> ) | ((i & ) << (lm - ));

     }

     return;

 }

 inline void NTT(int *a, int n, int f) {

     prework(n);

     for(int i = ; i < n; i++) {

         if(i < r[i]) {

             std::swap(a[i], a[r[i]]);

         }

     }

     for(int len = ; len < n; len <<= ) {

         int Wn = qpow(, (MO - ) / (len << ));

         if(f == -) Wn = Inv(Wn);

         for(int i = ; i < n; i += (len << )) {

             int w = ;

             for(int j = ; j < len; j++) {

                 int t = 1ll * a[i + len + j] * w % MO;

                 a[i + len + j] = (a[i + j] - t) % MO;

                 a[i + j] = (a[i + j] + t) % MO;

                 w = 1ll * w * Wn % MO;

             }

         }

     }

     if(f == -) {

         int inv = Inv(n);

         for(int i = ; i < n; i++) {

             a[i] = 1ll * a[i] * inv % MO;

         }

     }

     return;

 }

 int main() {

     scanf("%d%d", &n, &K);

     fac[] = inv[] = invn[] = ;

     fac[] = inv[] = invn[] = ;

     for(int i = ; i <= n * K; i++) {

         fac[i] = 1ll * fac[i - ] * i % MO;

         inv[i] = 1ll * inv[MO % i] * (MO - MO / i) % MO;

         invn[i] = 1ll * invn[i - ] * inv[i] % MO;

     }

     int len = ;

     while(len <= n * K) len <<= ;

     g[][] = ;

     memcpy(B, invn, K * sizeof(int));

     NTT(B, len, );

     for(int i = ; i <= n; i++) {

         /*for(int j = 0; j <= i * K; j++) {

             /// g[i][j] f[i][j]

             for(int k = 0; k < K && k <= j; k++) {

                 g[i][j] = (g[i][j] + 1ll * g[i - 1][j - k] * invn[k] % MO) % MO;

                 f[i][j] = (f[i][j] + 1ll * f[i - 1][j - k] * invn[k] % MO) % MO;

             }

             if(j >= K) f[i][j] = (f[i][j] + 1ll * g[i - 1][j - K] * invn[K - 1] % MO) % MO;

         }*/

         memcpy(A, g[i - ], n * K * sizeof(int));

         memset(A + n * K, , (len - n * K) * sizeof(int));

         NTT(A, len, );

         for(int j = ; j < len; j++) {

             A[j] = 1ll * A[j] * B[j] % MO;

         }

         NTT(A, len, -);

         for(int j = ; j <= i * K; j++) {

             g[i][j] = A[j];

         }

         memcpy(A, f[i - ], n * K * sizeof(int));

         memset(A + n * K, , (len - n * K) * sizeof(int));

         NTT(A, len, );

         for(int j = ; j < len; j++) {

             A[j] = 1ll * A[j] * B[j] % MO;

         }

         NTT(A, len, -);

         for(int j = ; j <= i * K; j++) {

             f[i][j] = A[j];

             if(j >= K) {

                 f[i][j] = (f[i][j] + 1ll * g[i - ][j - K] * invn[K - ] % MO) % MO;

             }

         }

     }

     int ans = ;

     for(int i = ; i <= n; i++) {

         int temp = ;

         for(int j = K - ; j <= i * K; j++) {

             temp = (temp + 1ll * fac[j - ] * f[i][j] % MO * qpow(inv[i], j) % MO * j % MO) % MO;

         }

         temp = 1ll * temp * n % MO * inv[i] % MO * C(n, i) % MO;

         if(i & ) {

             ans = (ans + temp) % MO;

         }

         else {

             ans = (ans - temp) % MO;

         }

     }

     printf("%d\n", (ans + MO) % MO);

     return ;

 }