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.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;




public class B {

	/**
	 * @param args
	 */
	
	static int dividors[][];
	static int firstcnt = 0;
	static long mod = 1073741824;
	
	
	public static void main(String[] args) {
		Parser p = new Parser(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		long a = p.nextInt();
		long b = p.nextInt();
		long c = p.nextInt();
		
		int first[] = new int[50];
		boolean isFirst[] = new boolean [101];
		Arrays.fill(isFirst, true);
		for(int i=2; i<100; ++i){
			if(isFirst[i]){
				first[firstcnt++] = i;
				int k =2;
				while(k*i<=100){
					isFirst[k*i] = false;
					++k;
				}
			}
		}
		dividors = new int[101][firstcnt];
		for(int i = 1; i<=100; ++i){
			Arrays.fill(dividors[i], 0);
			int tmp = i;
			for(int j=0; j<firstcnt; ++j){
				while(tmp%first[j] == 0){
					++dividors[i][j];
					tmp = tmp/first[j];
				}
				if(tmp == 1)
					break;
			}
			//System.out.println(Arrays.toString(dividors[i]));
		}
		

		long result = 0;
		
		for(int i = 1; i<=a; ++i){
			for(int k=1; k<=b; ++k){
				for(int l=1; l<=c; ++l){
					result+=sum(i,k,l);
				}
			}
		}
		
		pw.println(result);
		pw.close();
	}

	
	
	
	
	private static long sum(int i, int k, int l) {
		long cnt = 1;
		for(int f = 0; f<firstcnt; ++f){
			cnt=(cnt*(dividors[i][f]+dividors[k][f]+dividors[l][f]+1))%mod;
		}
		return cnt;
	}
















	static class Parser{
		
		StringTokenizer st;
		BufferedReader br;

		public Parser(InputStream is){
			this.br = new BufferedReader( new InputStreamReader(is));
			
		}
		
		public int nextInt(){
			return Integer.parseInt(nextToken());
		}
		
		public double nextDouble(){
			return Double.parseDouble(nextToken());
		}
		
		public String nextString(){
			return nextToken();
		}
		
		public int[] nextIntArray(int s){
			int[] a = new int[s];
			for(int i=0; i<s; ++i){
				a[i] = nextInt();
			}
			return a;
		}
		
		public int[][] nextIntTable(int r, int c){
			int[][] a = new int[r][c];
			for(int i=0; i<r; ++i){
				a[i] = nextIntArray(c);
			}
			return a;
		}
	
		private String nextToken() {
			if( st == null || ! st.hasMoreTokens() ){
				try{
					st = new StringTokenizer( br.readLine());
				}catch( Exception e){
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}
		
	}
}