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 maxn = 100050, maxm = 40;
int dfs(int, int, int, int);
int F[maxm + 1][maxm + 1][maxm + 1];
int e[maxn + 10], d[maxn + 10];
int g[maxn + 10];
int p[maxn + 10], cnt;
bool f[maxn + 10];
int main() {
  d[1] = 1;
  for (int i = 2; i <= maxn; i++) {
    if (!f[i]) p[++cnt] = i, e[i] = 1, d[i] = 2;
    for (int j = 1; j <= cnt && i * p[j] <= maxn; j++) {
      f[i * p[j]] = true;
      if (i % p[j])
        d[i * p[j]] = d[i] << 1, e[i * p[j]] = 1;
      else {
        e[i * p[j]] = e[i] + 1;
        d[i * p[j]] = d[i] / e[i * p[j]] * (e[i * p[j]] + 1);
        break;
      }
    }
  }
  for (int i = 1; i <= maxn; i++) g[i] = g[i - 1] + d[i];
  for (int i = 1; i <= maxm; i++)
    for (int j = 1; j <= maxm; j++)
      for (int k = 1; k <= maxm; k++)
        F[i][j][k] = F[i - 1][j][k] + F[i][j - 1][k] + F[i][j][k - 1] -
                     F[i - 1][j - 1][k] - F[i - 1][j][k - 1] -
                     F[i][j - 1][k - 1] + F[i - 1][j - 1][k - 1] + d[i * j * k];
  int a, b, c;
  scanf("%d %d %d", &a, &b, &c);
  int x = 0;
  while (p[x + 1] <= a || p[x + 1] <= b || p[x + 1] <= c) x++;
  printf("%d\n", dfs(a, b, c, x) & ((1 << 30) - 1));
  return 0;
}
int dfs(const int a, const int b, const int c, const int x) {
  if (!x) return g[a] * g[b] * g[c];
  int pr = p[x], v = a;
  if (v < b) v = b;
  if (v < c) v = c;
  if (v <= maxm && v < pr) return F[a][b][c];
  if (!a || !b || !c) return 0;
  int ret = dfs(a, b, c, x - 1);
  if (a >= pr && b >= pr && c >= pr)
    ret += (dfs(a / pr, b / pr, c / pr, x - 1) << 1);
  if (a >= pr && b >= pr) ret -= dfs(a / pr, b / pr, c, x - 1);
  if (a >= pr && c >= pr) ret -= dfs(a / pr, b, c / pr, x - 1);
  if (b >= pr && c >= pr) ret -= dfs(a, b / pr, c / pr, x - 1);
  return ret;
}