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.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
	public static void main(String[] args) throws IOException {
		Task task = new Task();
		task.getData();
		task.solve();
		task.printAnswer();
	}
}

class Task {
	int a, b, c;
	final int modulo = (int)Math.pow(2, 30);

	StringBuilder answer = new StringBuilder();
	// int answer = 0;

	public void getData() throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//BufferedReader br = new BufferedReader(new FileReader("input.txt"));

		String[] data = br.readLine().split(" ");
		a = Integer.parseInt(data[0]);
		b = Integer.parseInt(data[1]);
		c = Integer.parseInt(data[2]);

		br.close();
	}

	public void solve() {
		int[] d = new int[a * b * c + 1];
		for (int i = 1; i < d.length; ++i) {
			for (int j = 1; i * j < d.length; ++j) {
				++d[i * j];
			}
		}
		
		int sum = 0;
		for (int i = 1; i <= a; ++i) {
			for (int j = 1; j <= b; ++j) {
				for (int k = 1; k <= c; ++k) {
					sum = (sum + d[i * j * k]) % modulo;
				}
			}
		}
		answer.append(sum);
	}

	public void printAnswer() throws IOException {
		System.out.print(answer);
		/*
		BufferedWriter bw = new BufferedWriter(new FileWriter(new
		File("output.txt")));
		bw.append(answer);
		bw.close();
		*/
	}
}

class Pair {
	int first;
	int second;
	
	Pair(int first, int second) {
		this.first = first;
		this.second = second;
	}
}

class Library extends Object {
	public static long binomial(long n, long k) {
		if (k == 0 || n == k) {
			return 1;
		}
		
		return binomial(n - 1, k - 1) + binomial(n - 1, k);
	}
	
	public static ArrayList<ArrayList<Integer>> permutation(int n) {
		ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
		
		if (n == 1) {
			ArrayList<Integer> listToAdd = new ArrayList<Integer>(Arrays.asList(1));
			result.add(listToAdd);
			return result;
		}
		
		ArrayList<ArrayList<Integer>> old = permutation(n - 1);
		
		for (ArrayList<Integer> current : old) {
			for (int position = 0; position < n; ++position) {
				ArrayList<Integer> listToAdd = new ArrayList<Integer>();
				listToAdd.addAll(current.subList(0, position));
				listToAdd.add(n);
				listToAdd.addAll(current.subList(position, current.size()));
				result.add(listToAdd);
			}
		}
		return result;
	}
	
	public static ArrayList<Integer> firstPrimes(int bound) {
		boolean[] isPrime = new boolean[bound + 1];
		Arrays.fill(isPrime, 2, isPrime.length, true);
		for (int i = 2; i <= Math.sqrt(bound); ++i) {
			if (isPrime[i]) {
				for (int j = i * i; j <= bound; j += i) {
					isPrime[j] = false;
				}
			}
		}

		ArrayList<Integer> primes = new ArrayList<Integer>();
		for (int i = 0; i < isPrime.length; ++i) {
			if (isPrime[i]) {
				primes.add(i);
			}
		}
		return primes;
	}
}