#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int w, h;
long long c[3][3];
int inv[10];
int gcd(int a, int b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long collinear(int w, int h) {
  long long ret = 0;
  for (int w0 = 0; w0 <= w; ++w0)
    for (int h0 = 0; h0 <= h; ++h0)
      if (w0 + h0 != 0) {
        long long tmp = (long long)(w - w0 + 1) * (h - h0 + 1) % MOD *
                        (gcd(w0, h0) - 1) % MOD;
        if (w0 == 0 || h0 == 0)
          ret = (ret + tmp) % MOD;
        else
          ret = (ret + tmp * 2) % MOD;
      }
  return ret;
}
long long C(int x, int y) {
  long long ret = 1;
  for (int i = 1; i <= y; ++i) {
    ret = ret * (x - i + 1) % MOD * inv[i] % MOD;
  }
  return ret;
}
void calcInv(int n) {
  inv[1] = 1;
  for (int i = 2; i <= 10; i++) {
    inv[i] = (MOD - MOD / i) * inv[(int)(MOD % i)] % MOD;
    inv[i] = (inv[i] + MOD) % MOD;
  }
}
int main() {
  cin >> w >> h;
  int w_even = w / 2 + 1;
  int w_odd = (w + 1) / 2;
  int h_even = h / 2 + 1;
  int h_odd = (h + 1) / 2;
  calcInv(3);
  c[0][0] = w_even * h_even;
  c[0][1] = w_even * h_odd;
  c[1][0] = w_odd * h_even;
  c[1][1] = w_odd * h_odd;
  long long ans = C((w + 1) * (h + 1), 3) -
                  c[1][1] * c[1][0] % MOD * c[0][0] % MOD -
                  c[1][1] * c[0][1] % MOD * c[0][0] % MOD -
                  c[1][0] * c[0][1] % MOD * c[0][0] % MOD -
                  c[1][1] * c[1][0] % MOD * c[0][1] % MOD;
  ans = (ans % MOD + MOD) % MOD;
  ans = ans - collinear(w, h);
  ans = (ans % MOD + MOD) % MOD;
  ans = ans * 6 % MOD;
  cout << ans << endl;
}

### Prompt

Construct a CPP code solution to the problem outlined:

The Little Elephant is playing with the Cartesian coordinates' system. Most of all he likes playing with integer points. The Little Elephant defines an integer point as a pair of integers (x; y), such that 0 ≤ x ≤ w and 0 ≤ y ≤ h. Thus, the Little Elephant knows only (w + 1)·(h + 1) distinct integer points.

The Little Elephant wants to paint a triangle with vertexes at integer points, the triangle's area must be a positive integer. For that, he needs to find the number of groups of three points that form such triangle. At that, the order of points in a group matters, that is, the group of three points (0;0), (0;2), (2;2) isn't equal to the group (0;2), (0;0), (2;2).

Help the Little Elephant to find the number of groups of three integer points that form a nondegenerate triangle with integer area.

Input

A single line contains two integers w and h (1 ≤ w, h ≤ 4000).

Output

In a single output line print an integer — the remainder of dividing the answer to the problem by 1000000007 (109 + 7).

Examples

Input

2 1


Output

36


Input

2 2


Output

240

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int w, h;
long long c[3][3];
int inv[10];
int gcd(int a, int b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long collinear(int w, int h) {
  long long ret = 0;
  for (int w0 = 0; w0 <= w; ++w0)
    for (int h0 = 0; h0 <= h; ++h0)
      if (w0 + h0 != 0) {
        long long tmp = (long long)(w - w0 + 1) * (h - h0 + 1) % MOD *
                        (gcd(w0, h0) - 1) % MOD;
        if (w0 == 0 || h0 == 0)
          ret = (ret + tmp) % MOD;
        else
          ret = (ret + tmp * 2) % MOD;
      }
  return ret;
}
long long C(int x, int y) {
  long long ret = 1;
  for (int i = 1; i <= y; ++i) {
    ret = ret * (x - i + 1) % MOD * inv[i] % MOD;
  }
  return ret;
}
void calcInv(int n) {
  inv[1] = 1;
  for (int i = 2; i <= 10; i++) {
    inv[i] = (MOD - MOD / i) * inv[(int)(MOD % i)] % MOD;
    inv[i] = (inv[i] + MOD) % MOD;
  }
}
int main() {
  cin >> w >> h;
  int w_even = w / 2 + 1;
  int w_odd = (w + 1) / 2;
  int h_even = h / 2 + 1;
  int h_odd = (h + 1) / 2;
  calcInv(3);
  c[0][0] = w_even * h_even;
  c[0][1] = w_even * h_odd;
  c[1][0] = w_odd * h_even;
  c[1][1] = w_odd * h_odd;
  long long ans = C((w + 1) * (h + 1), 3) -
                  c[1][1] * c[1][0] % MOD * c[0][0] % MOD -
                  c[1][1] * c[0][1] % MOD * c[0][0] % MOD -
                  c[1][0] * c[0][1] % MOD * c[0][0] % MOD -
                  c[1][1] * c[1][0] % MOD * c[0][1] % MOD;
  ans = (ans % MOD + MOD) % MOD;
  ans = ans - collinear(w, h);
  ans = (ans % MOD + MOD) % MOD;
  ans = ans * 6 % MOD;
  cout << ans << endl;
}

```