Dreamoon loves summing up something for no reason. One day he obtains two integers a and b occasionally. He wants to calculate the sum of all nice integers. Positive integer x is called nice if <image> and <image>, where k is some integer number in range [1, a].

By <image> we denote the quotient of integer division of x and y. By <image> we denote the remainder of integer division of x and y. You can read more about these operations here: http://goo.gl/AcsXhT.

The answer may be large, so please print its remainder modulo 1 000 000 007 (109 + 7). Can you compute it faster than Dreamoon?

Input

The single line of the input contains two integers a, b (1 ≤ a, b ≤ 107).

Output

Print a single integer representing the answer modulo 1 000 000 007 (109 + 7).

Examples

Input

1 1


Output

0


Input

2 2


Output

8

Note

For the first sample, there are no nice integers because <image> is always zero.

For the second sample, the set of nice integers is {3, 5}.
#!/usr/bin/env python3

from math import ceil, sqrt

MOD = 10**9 + 7

def read_ints():
    return map(int, input().strip().split())

def partial(d, step, b, a):
    k = ((a*d)//step)

    a = (step*b + d)
    b = (k*step*b + d)

    return ((((a+b)*k)//2)%MOD)

assert partial(1, 1, 2, 2) == 3 + 5
assert partial(1, 1, 4, 4) == 5 + 9 + 13 + 17
assert partial(3, 3, 4, 2) == 15 + 27

def bigsum(a, b):
    sigma = (b*(b-1)//2)
    return ((a*(2+b*(a+1))*sigma)//2) % MOD


def full(a, b):
    sum = bigsum(a, b)

    def corsum(d, sum):
        sum = (sum - partial(d, d, b, a) + partial(d, 1, b, a))%MOD

    for d in range(1, ceil(sqrt(b))+1):
        if b % d == 0:
            corsum(d, sum)
            if d*d != b:
                corsum(b/d, sum)

    return sum


a, b = read_ints()
print(full(a, b))
