#include<bits/stdc++.h>

using namespace std;

using int64 = long long;
const int mod = 1e9 + 7;

int N, K;
int64 fact[101];
int64 dp[101][100001];

int rec(int idx, int add)
{
  if(idx == 0) return (0);
  if(~dp[idx][add]) return (dp[idx][add]);
  long long ret = 0;
  for(int i = 0; i <= K; i++) {
    if(i <= idx && idx <= add + i) {
      int sqr = (add + i) % idx;
      (ret += 1LL * fact[idx - 1] * sqr % mod) % mod;
      (ret += rec(idx - 1, add + (add + i) / idx)) %= mod;
    } else {
      (ret += 1LL * fact[idx - 1] * (i + add) % mod) %= mod;
      (ret += rec(idx - 1, add)) %= mod;
    }
  }
  return (dp[idx][add] = ret);
}

int main()
{
  cin >> N >> K;
  fact[0] = 1;
  for(int i = 1; i <= N; i++) {
    (fact[i] = fact[i - 1] * (K + 1)) %= mod;
  }
  memset(dp, -1, sizeof(dp));
  cout << rec(N, 0) << endl;
}
### Prompt

Create a solution in Cpp for the following problem:

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<bits/stdc++.h>

using namespace std;

using int64 = long long;
const int mod = 1e9 + 7;

int N, K;
int64 fact[101];
int64 dp[101][100001];

int rec(int idx, int add)
{
  if(idx == 0) return (0);
  if(~dp[idx][add]) return (dp[idx][add]);
  long long ret = 0;
  for(int i = 0; i <= K; i++) {
    if(i <= idx && idx <= add + i) {
      int sqr = (add + i) % idx;
      (ret += 1LL * fact[idx - 1] * sqr % mod) % mod;
      (ret += rec(idx - 1, add + (add + i) / idx)) %= mod;
    } else {
      (ret += 1LL * fact[idx - 1] * (i + add) % mod) %= mod;
      (ret += rec(idx - 1, add)) %= mod;
    }
  }
  return (dp[idx][add] = ret);
}

int main()
{
  cin >> N >> K;
  fact[0] = 1;
  for(int i = 1; i <= N; i++) {
    (fact[i] = fact[i - 1] * (K + 1)) %= mod;
  }
  memset(dp, -1, sizeof(dp));
  cout << rec(N, 0) << endl;
}
```