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.*;

/*************************************************************************
 *  219D Codeforce
 * 
 *************************************************************************/
public class Sourcecode {
    
    
    
    public static boolean Isprime(int number){
        if(number==2) return true;
        int upperbound=(int) Math.sqrt((double)number);
        for(int i=2;i<=upperbound;i++){
            if(number%i==0) return false;
        }
        return true;
    }
    public static int firstprimeafter(int oldprime){
        int n;
        if(oldprime==2){
            n=3;
        }
        else{
            n=oldprime+2;
        }
        while(!Isprime(n)) n=n+2;
        return n;
        
    }
    
    public static HashMap<Integer,Integer> Primerepresent(int integertosplit){
        HashMap<Integer,Integer> resultset=new HashMap<Integer,Integer>(); 
        int iter=integertosplit;
        int currentprime=2;
        while(iter!=1){
            int tmpcount=0;
            while(iter%currentprime==0){
                iter=iter/currentprime;
                tmpcount++;
            }
            if (tmpcount>0){
            resultset.put(currentprime, tmpcount);
            //System.out.println("put:"+currentprime+"-"+tmpcount);
            }
            currentprime=firstprimeafter(currentprime);
        }
        return resultset;
        
    }
    
    public static HashMap<Integer,Integer> MergeHash(HashMap<Integer,Integer> hash1,HashMap<Integer,Integer> hash2,HashMap<Integer,Integer> hash3){
        for(Integer key : hash2.keySet()){
            if(hash1.containsKey(key)){
                int hash1value=hash1.get(key);
                int hash2value=hash2.get(key);
                int newhashvalue=hash1value+hash2value;
                hash1.put(key, newhashvalue);
            }
            else{
                hash1.put(key, hash2.get(key));
            }
        }
        for(Integer key:hash3.keySet()){
            if(hash1.containsKey(key)){
                int hash1value=hash1.get(key);
                int hash3value=hash3.get(key);
                int newhashvalue=hash1value+hash3value;
                hash1.put(key, newhashvalue);   
            }
            else{
                hash1.put(key, hash3.get(key));
            }
        }
        return hash1;
    }
    
    public static int countdivisor(HashMap<Integer,Integer> hash){
        int sum=1;
        for(Integer key : hash.keySet() ){
            int power=hash.get(key);
            int addon=power+1;
            sum*=addon;
        }
        return sum;
    }
    
    public static void main (String[] args) {
    
        Scanner input=new Scanner(System.in);
        int a=input.nextInt();
        int b=input.nextInt();
        int c=input.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++){
                
                    int product=i*j*k;
                    HashMap<Integer,Integer> hash123=Primerepresent(product);
                    int addon=countdivisor(hash123);
                    sum+=addon;
                    
                }
            }
        }
        System.out.println(sum);
    
        
    }

    
     

    }

      
    
    
  
