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

public class B_Easy_Number_Challenge {
    double PI = 3.141592653589793238462643383279502884197169399375105820974944;
    int MOD = 1000000007;

    public static void main(String[] args) {
        FastScanner f = new FastScanner();
        int a=f.ri();
        int b=f.ri();
        int c=f.ri();
        long count=0L;
        int value=a*b*c;
        int arr[]=new int[value+1];
        for(int i=1;i<=a;i++){
            for(int j=1;j<=b;j++){
                for(int k=1;k<=c;k++){
                    int val=arr[i*j*k];
                    if(val==0){
                        arr[i*j*k]=noOfDivisors(i*j*k);
                        val=arr[i*j*k];
                    }
                    // System.out.println(i*j*k+"  "+ val);
                    count+=val;
                    count=count%1073741824;

                }
            }
        }
        System.out.println(count);

    }
    public static int noOfDivisors(int n){
        // System.out.println(n);
        if(n==1){
            return 1;
        }

        else if(n==2||n==3||n==5){
            return 2;
        }

        else{
            int count=0;
            for(int i=1;i*i<=n;i++){
                if(n%i==0){
                   if(i*i==n){
                       count++;
                   }
                   else{
                       count+=2;
                   }
                }
            }
            
            return count;
        }
    }

    // any other class you make,make it static.

    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String rs() {
            while (!st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int ri() {
            return Integer.parseInt(rs());
        }

        int[] rarr(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = ri();
            return a;
        }

        long rl() {
            return Long.parseLong(rs());
        }
    }

    static void sort(int[] a) {
        ArrayList<Integer> l = new ArrayList<>();
        for (int i : a)
            l.add(i);
        Collections.sort(l);
        for (int i = 0; i < a.length; i++)
            a[i] = l.get(i);
    }

    static int gcd(int a, int b) {
        return (b == 0) ? a : gcd(b, a % b);
    }

    static long ncr(int n, int k) // note it returns long
    {
        if (k > n - k) {
            k = n - k;
        }
        long c[] = new long[k + 1];
        c[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = Math.min(i, k); j > 0; j--) {
                c[j] = c[j] + c[j - 1];
                // c[j]=c[j]%(1000000000+7);when asked or int is used instead of long
            }
        }
        return c[k];
    }

    public void nextPermutation(int[] nums) {
        int mark = -1;
        for (int i = nums.length - 1; i > 0; i--) {
            if (nums[i] > nums[i - 1]) {
                mark = i - 1;
                break;
            }
        }

        if (mark == -1) {
            reverse(nums, 0, nums.length - 1);
            return;
        }

        int idx = nums.length - 1;
        for (int i = nums.length - 1; i >= mark + 1; i--) {
            if (nums[i] > nums[mark]) {
                idx = i;
                break;
            }
        }

        swap(nums, mark, idx);

        reverse(nums, mark + 1, nums.length - 1);
    }

    public void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }

    public void reverse(int[] nums, int i, int j) {
        while (i < j) {
            swap(nums, i, j);
            i++;
            j--;
        }
    }

}
