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.
// Java program to find prime factorization of a 
// number n in O(Log n) time with precomputation 
// allowed. 

import java.util.*; 

public class Test 
{ 
	static final int MAXN = 1000001; 
	
	// stores smallest prime factor for every number 
	static int spf[] = new int[MAXN]; 
	
	// Calculating SPF (Smallest Prime Factor) for every 
	// number till MAXN. 
	// Time Complexity : O(nloglogn) 
	static void sieve() 
	{ 
		spf[1] = 1; 
		for (int i=2; i<MAXN; i++) 
	
			// marking smallest prime factor for every 
			// number to be itself. 
			spf[i] = i; 
	
		// separately marking spf for every even 
		// number as 2 
		for (int i=4; i<MAXN; i+=2) 
			spf[i] = 2; 
	
		for (int i=3; i*i<MAXN; i++) 
		{ 
			// checking if i is prime 
			if (spf[i] == i) 
			{ 
				// marking SPF for all numbers divisible by i 
				for (int j=i*i; j<MAXN; j+=i) 
	
					// marking spf[j] if it is not 
					// previously marked 
					if (spf[j]==j) 
						spf[j] = i; 
			} 
		} 
	} 
	
	// A O(log n) function returning primefactorization 
	// by dividing by smallest prime factor at every step 
	static HashMap<Integer,Integer> getFactorization(int x) 
	{ 
		Vector<Integer> ret = new Vector<>(); 
		HashMap<Integer,Integer> map=new HashMap<>();
		while (x != 1) 
		{ 
		    if(map.containsKey(spf[x])==false)
		    map.put(spf[x],1);
		    else
		    map.put(spf[x],map.get(spf[x])+1);
			ret.add(spf[x]); 
			x = x / spf[x]; 
		} 
		return map; 
	} 
	
	// Driver method 
	public static void main(String args[]) 
	{ 
		// precalculating Smallest Prime Factor 
		sieve(); 
		int x = 10; 
		//System.out.print("prime factorization for " + x + " : "); 
		int factors[]=new int[1000001];
		for(int i=1;i<=1000000;i++)
		{
		    x=i;
	    int prod=1;
		// calling getFactorization function 
		HashMap<Integer,Integer> p =new HashMap<>();
		p= getFactorization(x); 
		for( Map.Entry<Integer, Integer> entry : p.entrySet() )
		{
		    int value=entry.getValue();
		    prod*=(value+1);
		}
		factors[i]=prod;
		}
		
		Scanner in=new Scanner(System.in);int a=0,b=0,c=0;
		if(in.hasNext())
     a=in.nextInt();
     if(in.hasNext())
     b=in.nextInt();
     if(in.hasNext())
     c=in.nextInt();
     
     long sum=0;
     int pr=1;
     int p=1073741824;
     for(int i=1;i<=a;i++)
     {
         for(int j=1;j<=b;j++)
     {
         for(int k=1;k<=c;k++)
     {
         pr=i*j*k;
         //System.out.println("pr="+pr);
         sum=(sum%p+factors[pr]%p)%p;
     }
     }
     }
     
 //   System.out.println( entry.getKey() + " => " + entry.getValue() );

	   
	//	for (int i=0; i<p.size(); i++) 
	//		System.out.print(p.get(i) + " "); 
		System.out.println(sum); 
	} 
} 
