Problem: Let's denote d(n) as the number of divisors of a positive integer n. You are given three integers a, b and c. Your task is to calculate the following sum:

<image>

Find the sum modulo 1073741824 (230).

Input

The first line contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 2000).

Output

Print a single integer — the required sum modulo 1073741824 (230).

Examples

Input

2 2 2


Output

20


Input

4 4 4


Output

328


Input

10 10 10


Output

11536

Note

For the first example.

  * d(1·1·1) = d(1) = 1; 
  * d(1·1·2) = d(2) = 2; 
  * d(1·2·1) = d(2) = 2; 
  * d(1·2·2) = d(4) = 3; 
  * d(2·1·1) = d(2) = 2; 
  * d(2·1·2) = d(4) = 3; 
  * d(2·2·1) = d(4) = 3; 
  * d(2·2·2) = d(8) = 4. 



So the result is 1 + 2 + 2 + 3 + 2 + 3 + 3 + 4 = 20.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int T, n, A, B, C, cnt, p[N], mu[N], du[N], fe[N], tot;
long long a[N], b[N], c[N];
bool np[N];
void init() {
  mu[1] = 1;
  for (int i = 2; i <= n; i++) {
    if (!np[i]) p[++cnt] = i, mu[i] = -1;
    for (int j = 1; j <= cnt && i * p[j] <= n; j++) {
      np[i * p[j]] = 1;
      if (i % p[j] == 0) break;
      mu[i * p[j]] = -mu[i];
    }
  }
}
struct edge {
  int u, v, w;
};
struct _ {
  int v, w;
};
vector<_> G[N];
int main() {
  n = 10000;
  init();
  scanf("%d%d%d", &A, &B, &C);
  n = max(A, max(B, C));
  for (int i = 0; i <= n; i++) a[i] = b[i] = c[i] = du[i] = 0, G[i].clear();
  for (int i = 1; i <= A; i++)
    for (int j = i; j <= A; j += i) a[i] += A / j;
  for (int i = 1; i <= B; i++)
    for (int j = i; j <= B; j += i) b[i] += B / j;
  for (int i = 1; i <= C; i++)
    for (int j = i; j <= C; j += i) c[i] += C / j;
  long long ans = 0;
  for (int i = 1; i <= n; i++)
    ans += mu[i] * mu[i] * mu[i] * a[i] * b[i] * c[i];
  vector<edge> e;
  for (int d = 1; d <= n; d++)
    for (int i = 1, l = n / d; i <= l; i++)
      if (mu[i * d])
        for (int j = i + 1, r = n / d / i; j <= r; j++)
          if (mu[j * d] && gcd(i, j) == 1) {
            int u = i * d, v = j * d, lcm = i * j * d;
            ans += mu[u] * mu[u] * mu[v] *
                   (a[u] * b[lcm] * c[lcm] + a[lcm] * b[u] * c[lcm] +
                    a[lcm] * b[lcm] * c[u]);
            ans += mu[u] * mu[v] * mu[v] *
                   (a[v] * b[lcm] * c[lcm] + a[lcm] * b[v] * c[lcm] +
                    a[lcm] * b[lcm] * c[v]);
            ++du[u];
            ++du[v];
            e.push_back((edge){u, v, lcm});
          }
  for (auto &f : e)
    if (du[f.u] > du[f.v] || (du[f.u] == du[f.v] && f.u < f.v))
      G[f.u].push_back((_){f.v, f.w});
    else
      G[f.v].push_back((_){f.u, f.w});
  for (int u = 1; u <= n; u++) {
    for (auto &f : G[u]) fe[f.v] = f.w;
    for (auto &f : G[u])
      for (auto &p : G[f.v])
        if (fe[p.v])
          ans += mu[u] * mu[f.v] * mu[p.v] *
                 (a[f.w] * b[p.w] * c[fe[p.v]] + a[f.w] * b[fe[p.v]] * c[p.w] +
                  a[p.w] * b[f.w] * c[fe[p.v]] + a[fe[p.v]] * b[f.w] * c[p.w] +
                  a[fe[p.v]] * b[p.w] * c[f.w] + a[p.w] * b[fe[p.v]] * c[f.w]);
    for (auto &f : G[u]) fe[f.v] = 0;
  }
  printf("%d\n", int(ans & ((1 << 30) - 1)));
}