#include <cstddef>
#include <cstdint>
#include <iostream>
#include <string>

using usize = std::size_t;
using u64 = std::uint64_t;

static constexpr u64 mod = 1000000007;

int main() {
  u64 n, m;
  std::cin >> n >> m;
  u64 ans = 0;
  if (n == 1) {
    ans = (m + 1) % mod;
  } else {
    const auto choose = [&](u64 x) {
      x %= mod;
      return x * x % mod;
    };
    u64 lar = m % (n - 1) + 1;
    u64 sma = (n - 1) - lar;
    ans += choose(m / (n - 1) + 1) * (lar % mod) % mod;
    ans += choose(m / (n - 1)) * (sma % mod) % mod;
    ans %= mod;
  }
  std::cout << ans << std::endl;
  return 0;
}

### Prompt

Please formulate a Cpp solution to the following problem:

B: Ebi-chan and Integer Sequences-

problem

Ebi-chan likes sequences. I especially like arithmetic progressions. This time, I decided to create a sequence that meets the following conditions.

* Arithmetic progression of length n
* When the i-th element of the sequence is defined as s_i, all s_i (1 \ leq i \ leq n) are integers that satisfy 0 \ leq s_i \ leq m.



How many sequences are there that satisfy the above conditions? However, the answer can be very large, so print the remainder after dividing by 10 ^ 9 + 7.

Input format

Input is given in one line.


n m

n represents the length of the sequence.

Constraint

* 1 \ leq n \ leq 10 ^ {15}
* 0 \ leq m \ leq 10 ^ {15}



Output format

Divide the number of arithmetic progressions that satisfy the condition by 10 ^ 9 + 7 and output the remainder in one row.

Input example 1


3 9

Output example 1


50

Input example 2


10000000000 10000000000

Output example 2


999999942

Note that the input does not fit in a 32-bit integer.





Example

Input

3 9


Output

50

### Response

```cpp
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <string>

using usize = std::size_t;
using u64 = std::uint64_t;

static constexpr u64 mod = 1000000007;

int main() {
  u64 n, m;
  std::cin >> n >> m;
  u64 ans = 0;
  if (n == 1) {
    ans = (m + 1) % mod;
  } else {
    const auto choose = [&](u64 x) {
      x %= mod;
      return x * x % mod;
    };
    u64 lar = m % (n - 1) + 1;
    u64 sma = (n - 1) - lar;
    ans += choose(m / (n - 1) + 1) * (lar % mod) % mod;
    ans += choose(m / (n - 1)) * (sma % mod) % mod;
    ans %= mod;
  }
  std::cout << ans << std::endl;
  return 0;
}

```