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 ≤ 100).

Output

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

Examples

Input

2 2 2


Output

20


Input

5 6 7


Output

1520

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.
import java.util.*;
import java.io.*;

/**
 * @author El Mehdi ASSALI
 */
public class CF_236B {
  static class Solver {
    final int MOD = 1 << 30;
    final int MAX = (int) 1e6 + 7;
    final int[] spf = new int[MAX];

    void solve(IO io) throws Exception {
      init();
      int a = io.nextInt();
      int b = io.nextInt();
      int c = io.nextInt();
      int sum = 0;
      for (int i = 1; i <= a; i++) {
        for (int j = 1; j <= b; j++) {
          for (int k = 1; k <= c; k++) {
            sum = add(sum, numberOfDivisors(i * j * k));
          }
        }
      }
      io.println(sum);
    }

    void init() {
      for (int i = 2; i < MAX; i++) {
        spf[i] = i % 2 == 0 ? 2 : i;
      }
      for (int i = 3; i < MAX; i++) {
        if (spf[i] == i) {
          for (int j = i + i; j < MAX; j += i) {
            if (spf[j] == j) {
              spf[j] = i;
            }
          }
        }
      }
    }

    int numberOfDivisors(int n) {
      HashMap<Integer, Integer> count = new HashMap<>();
      while (n > 1) {
        count.putIfAbsent(spf[n], 0);
        count.put(spf[n], count.get(spf[n]) + 1);
        n /= spf[n];
      }
      if (n > 1) {
        count.putIfAbsent(n, 0);
        count.put(n, count.get(n) + 1);
      }
      int sum = 1;
      for (Map.Entry<Integer, Integer> entry : count.entrySet()) {
        sum *= entry.getValue() + 1;
      }
      return sum;
    }

    int add(int a, int b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }
  }

  public static void main(String... args) {
    try (IO io = new IO()) {
      new Solver().solve(io);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  static class IO implements AutoCloseable {
    BufferedReader reader;
    PrintWriter writer;
    StringTokenizer tokenizer;

    IO() {
      reader = new BufferedReader(new InputStreamReader(System.in));
      writer = new PrintWriter(System.out);
    }

    String next() throws Exception {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        tokenizer = new StringTokenizer(reader.readLine());
      }
      return tokenizer.nextToken();
    }

    int nextInt() throws Exception {
      return Integer.parseInt(next());
    }

    long nextLong() throws Exception {
      return Long.parseLong(next());
    }

    double nextDouble() throws Exception {
      return Double.parseDouble(next());
    }

    int[] nextIntArr(int offset, int size) throws Exception {
      int[] arr = new int[offset + size];
      for (int i = offset; i < offset + size; i++) {
        arr[i] = nextInt();
      }
      return arr;
    }

    long[] nextLongArr(int offset, int size) throws Exception {
      long[] arr = new long[offset + size];
      for (int i = offset; i < offset + size; i++) {
        arr[i] = nextLong();
      }
      return arr;
    }

    void print(Object o) {
      writer.print(o);
    }

    void println(Object o) {
      writer.println(o);
    }

    void printf(String format, Object... args) {
      writer.printf(format, args);
    }

    @Override
    public void close() throws Exception {
      reader.close();
      writer.close();
    }
  }
}