#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <set>
#include <map>

using namespace std;
typedef long long ll;

const ll MOD = 1000000007;
ll dp[101][10001];

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(10) << fixed;
    int N, K;
    cin >> N >> K;
    if(N == K) {
        dp[N][0] = N;
        dp[N][1] = 1;
    }else{
        dp[N][0] = K+1;
    }
    for(int i = N-1; i >= 1; i--){
        for(int j = N*K; j >= 0; j--){
            if(dp[i+1][j] > 0){
                for(int k = 0; k <= K; k++){
                    if(k < i){
                        dp[i][j+(k+j)/i] += dp[i+1][j];
                        dp[i][j+(k+j)/i] %= MOD;
                    }
                    if(k == i){
                        dp[i][1+j/i+j] += dp[i+1][j];
                        dp[i][1+j/i+j] %= MOD;
                    }
                    if(k > i){
                        dp[i][j] += dp[i+1][j];
                        dp[i][j] %= MOD;
                    }
                }
            }
        }
    }
    ll pow = 1;
    for(int i = 0; i < N-1; i++){
        pow *= (K+1);
        pow %= MOD;
    }
    ll sum = ((K*(K+1))/2)*N*pow;
    sum %= MOD;
    for(int j = N*K; j >= 0; j--){
        sum -= (ll)dp[1][j]*j;
        sum %= MOD;
        sum += MOD;
        sum %= MOD;
    }
    cout << sum << endl;
}
### Prompt

Construct a cpp code solution to the problem outlined:

Consider the following game:

* The game is played using a row of N squares and many stones.
* First, a_i stones are put in Square i\ (1 \leq i \leq N).
* A player can perform the following operation as many time as desired: "Select an integer i such that Square i contains exactly i stones. Remove all the stones from Square i, and add one stone to each of the i-1 squares from Square 1 to Square i-1."
* The final score of the player is the total number of the stones remaining in the squares.



For a sequence a of length N, let f(a) be the minimum score that can be obtained when the game is played on a.

Find the sum of f(a) over all sequences a of length N where each element is between 0 and K (inclusive). Since it can be extremely large, find the answer modulo 1000000007 (= 10^9+7).

Constraints

* 1 \leq N \leq 100
* 1 \leq K \leq N

Input

Input is given from Standard Input in the following format:


N K


Output

Print the sum of f(a) modulo 1000000007 (= 10^9+7).

Examples

Input

2 2


Output

10


Input

20 17


Output

983853488

### Response

```cpp
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <set>
#include <map>

using namespace std;
typedef long long ll;

const ll MOD = 1000000007;
ll dp[101][10001];

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(10) << fixed;
    int N, K;
    cin >> N >> K;
    if(N == K) {
        dp[N][0] = N;
        dp[N][1] = 1;
    }else{
        dp[N][0] = K+1;
    }
    for(int i = N-1; i >= 1; i--){
        for(int j = N*K; j >= 0; j--){
            if(dp[i+1][j] > 0){
                for(int k = 0; k <= K; k++){
                    if(k < i){
                        dp[i][j+(k+j)/i] += dp[i+1][j];
                        dp[i][j+(k+j)/i] %= MOD;
                    }
                    if(k == i){
                        dp[i][1+j/i+j] += dp[i+1][j];
                        dp[i][1+j/i+j] %= MOD;
                    }
                    if(k > i){
                        dp[i][j] += dp[i+1][j];
                        dp[i][j] %= MOD;
                    }
                }
            }
        }
    }
    ll pow = 1;
    for(int i = 0; i < N-1; i++){
        pow *= (K+1);
        pow %= MOD;
    }
    ll sum = ((K*(K+1))/2)*N*pow;
    sum %= MOD;
    for(int j = N*K; j >= 0; j--){
        sum -= (ll)dp[1][j]*j;
        sum %= MOD;
        sum += MOD;
        sum %= MOD;
    }
    cout << sum << endl;
}
```