Problem:
Problem Statement

Snuke loves colorful balls. He has a total of N×K balls, K in each of his favorite N colors. The colors are numbered 1 through N.

He will arrange all of the balls in a row from left to right, in arbitrary order. Then, for each of the N colors, he will paint the leftmost ball of that color into color 0, a color different from any of the N original colors.

After painting, how many sequences of the colors of the balls are possible? Find this number modulo 10^9+7.

Constraints

1≤N,K≤2,000

Input

The input is given from Standard Input in the following format:

N K

Output

Print the number of the possible sequences of the colors of the balls after painting, modulo 10^9+7.

Sample Input 1

2 2

Sample Output 1

4

The following 4 sequences are possible:

(0,1,0,2)

(0,0,1,2)

(0,2,0,1)

(0,0,2,1)

Sample Input 2

3 1

Sample Output 2

1

The following 1 sequence is possible:

(0,0,0)

Sample Input 3

2 3

Sample Output 3

14

Sample Input 4

2000 2000

Sample Output 4

546381702

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>

#define For(i, j, k) for(int i = j; i <= k; i++)
#define Forr(i, j, k) for(int i = j; i >= k; i--)

using namespace std;

typedef long long LL;

const int N = 2010;
const int Mod = 1e9 + 7;

LL Pow(LL x, LL e){
	LL ret = 1;
	while(e){
		if(e & 1) ret = ret * x % Mod;
		x = x * x % Mod;
		e >>= 1;
	}
	return ret;
}

LL fac[N * N], rfac[N * N];
int n, k;

inline LL C(int a, int b){
	return fac[a] * rfac[b] % Mod * rfac[a - b] % Mod;
}

LL dp[N][N];

int main(){
	scanf("%d%d", &n, &k);

	if(k == 1){
		puts("1");
		return 0;
	}
	
	fac[0] = 1;
	For(i, 1, n * k) fac[i] = fac[i - 1] * i % Mod;
	rfac[n * k] = Pow(fac[n * k], Mod - 2);
	Forr(i, n * k - 1, 0) rfac[i] = rfac[i + 1] * (i + 1) % Mod;

	dp[0][0] = 1;
	For(i, 0, n) For(j, i, n){
		(dp[i + 1][j] += dp[i][j]) %= Mod;
		(dp[i][j + 1] += dp[i][j] * C(i + (j + 1) * (k - 1) - 1, k - 2)) %= Mod;
	}

	printf("%lld\n", dp[n][n] * fac[n] % Mod);
	return 0;
}