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 JAVA):

Solution:
import java.awt.Point;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class B {

    static Map<Point, Integer> map = new HashMap<Point, Integer>();
    static Point end;

    public static void main(String[] Args) {
        new B().solve();
    }

    void solve() {
        int a = si(), b = si(), c = si();
        HashSet<Integer>[] v = d100();

        int m = 1073741824, o = 0;
        int[] p = new int[100 * 100 * 100 + 1];
        for (int i = 1; i <= a; i++) {
            for (int j = 1; j <= b; j++) {
                for (int k = 1; k <= c; k++) {

                    if (p[i * j * k] == 0) {
                        HashSet<Integer> h = new HashSet<Integer>();
                        h.add(i);
                        h.add(j);
                        h.add(k);
                        h.addAll(d(v[i], v[j], v[k]));
                        p[i * j * k] = h.size() % m;
                        o += h.size() % m;
                    } else
                        o += p[i * j * k];

                }
            }
        }

        System.out.println(o);
    }

    HashSet<Integer> d(HashSet<Integer> a, HashSet<Integer> b,
            HashSet<Integer> c) {
        HashSet<Integer> h = new HashSet<Integer>();
        for (int i : a)
            h.add(i);
        for (int i : b)
            h.add(i);
        for (int i : c)
            h.add(i);
        for (int i : a) {
            for (int j : b)
                for (int k : c)
                    h.add(i * j * k);
        }
        h.addAll(f(a, b));
        h.addAll(f(a, c));
        h.addAll(f(c, b));
        return h;
    }

    HashSet<Integer> f(HashSet<Integer> b, HashSet<Integer> c) {
        HashSet<Integer> h = new HashSet<Integer>();
        for (int j : b)
            for (int k : c)
                h.add(j * k);
        return h;
    }

    static HashSet[] d100() {
        HashSet<Integer>[] a = new HashSet[101];
        for (int i = 0; i < a.length; i++) {
            a[i] = new HashSet<Integer>();

            a[i].add(1);
            if (i != 0)
                a[i].add(i);
        }
        for (int i = 0; i < a.length; i++) {
            for (int j = i / 2; j > 1; j--) {
                if (i % j == 0)
                    a[i].add(j);
            }
        }
        return a;
    }

    static int toi(Object s) {
        return Integer.parseInt(s.toString());
    }

    // ----------------------- Library ------------------------
    static int[] dx = { 1, 0, -1, 1, -1, 1, 0, -1 }, dy = { 1, 1, 1, 0, 0, -1,
            -1, -1 };
    static Scanner scan = new Scanner(System.in);
    static int INF = 2147483647;

    // finds GCD of a and b using Euclidian algorithm
    public int GCD(int a, int b) {
        if (b == 0)
            return a;
        return GCD(b, a % b);
    }

    static List<String> toList(String[] a) {
        return Arrays.asList(a);
    }

    static String[] toArray(List<String> a) {
        String[] o = new String[a.size()];
        a.toArray(o);
        return o;
    }

    static int[] pair(int... a) {
        return a;
    }

    static int si() {
        return scan.nextInt();
    }

    static String ss() {
        return scan.next();
    }

    static int[] sai(int n) {
        int[] a = new int[n];
        for (int i = 0; i < a.length; i++)
            a[i] = si();

        return a;
    }

    static int[] sai_(int n) {
        int[] a = new int[n + 1];
        for (int i = 1; i <= n; i++)
            a[i] = si();

        return a;
    }

    static String[] sas(int n) {
        String[] a = new String[n];
        for (int i = 0; i < a.length; i++)
            a[i] = ss();
        return a;
    }

    static Object[][] _sm1(int r, int c) {
        Object[][] a = new Object[r][c];
        for (int i = 0; i < r; i++)
            for (int j = 0; j < c; j++)
                a[i][j] = scan.next();
        return a;
    }

    static Object[][] _sm2(int r) {
        Object[][] a = new Object[r][3];
        for (int i = 0; i < r; i++)
            a[i] = new Object[] { ss(), ss(), ss() };
        return a;
    }
}