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.*;
import java.math.BigInteger;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {

    static final int INF = Integer.MAX_VALUE;

    static void mergeSort(int[] a, int p, int r) {
        if (p < r) {
            int q = (p + r) / 2;
            mergeSort(a, p, q);
            mergeSort(a, q + 1, r);
            merge(a, p, q, r);
        }
    }

    static void merge(int[] a, int p, int q, int r) {
        int n1 = q - p + 1;
        int n2 = r - q;
        int[] L = new int[n1 + 1], R = new int[n2 + 1];
        // int[] L1 = new int[n1 + 1], R1 = new int[n2 + 1];

        for (int i = 0; i < n1; i++) {
            L[i] = a[p + i];
            //  L1[i] = b[p + i];

        }
        for (int i = 0; i < n2; i++) {
            R[i] = a[q + 1 + i];
            // R1[i] = b[q + 1 + i];

        }
        L[n1] = R[n2] = INF;
        // L1[n1] = R1[n2] = INF;

        for (int k = p, i = 0, j = 0; k <= r; k++) {
            if (L[i] <= R[j]) {

                a[k] = L[i++];
                //  b[k] = L1[i++];

            } else {
                a[k] = R[j++];
                // b[k] = R1[j++];

            }
        }
    }

    static void mergeSort(int[] a, int[] b, int[] c, int p, int r) {
        if (p < r) {
            int q = (p + r) / 2;
            mergeSort(a, b, c, p, q);
            mergeSort(a, b, c, q + 1, r);
            merge(a, b, c, p, q, r);
        }
    }

    static void merge(int[] a, int[] b, int[] c, int p, int q, int r) {
        int n1 = q - p + 1;
        int n2 = r - q;
        int[] L = new int[n1 + 1], R = new int[n2 + 1];
        int[] L1 = new int[n1 + 1], R1 = new int[n2 + 1];
        int[] L2 = new int[n1 + 1], R2 = new int[n2 + 1];
        // int[] L2 = new int[n1 + 1], R2 = new int[n2 + 1];

        for (int i = 0; i < n1; i++) {
            L[i] = a[p + i];
            L1[i] = b[p + i];
            L2[i] = c[p + i];
            // L2[i] = a[p + i];
        }
        for (int i = 0; i < n2; i++) {
            R[i] = a[q + 1 + i];
            R1[i] = b[q + 1 + i];
            R2[i] = c[q + 1 + i];
            //  R2[i] = a[q + 1 + i];
        }
        L[n1] = R[n2] = INF;
        L1[n1] = R1[n2] = INF;
        L2[n1] = R2[n2] = INF;
        int j = 0, k = 0;
        for (int i = p; i <= r; i++) {
            if (L[j] < R[k]) {
                a[i] = L[j];
                b[i] = L1[j];
                c[i] = L2[j++];
                //j++;
            } else if ((L[j] > R[k])) {
                a[i] = R[k];
                b[i] = R1[k];
                c[i] = R2[k++];
                //k++;
            } else {
                //des
                if (L1[j] < R1[k]) {
                    a[i] = L[j];
                    b[i] = L1[j];
                    c[i] = L2[j++];
                    //j++;
                } else {
                    a[i] = R[k];
                    b[i] = R1[k];
                    c[i] = R2[k++];
                }
            }

        }
    }

    public static int[] sieve(int n) {
        int a[] = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            a[i] = 1;
        }
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (a[i] == 1) {
                for (int k = 2; i * k <= n; k++) {
                    a[i * k] = 0;
                }
            }
        }
        return a;
    }

    public static int sum(int a) {
        int su = 0;
        while (a > 0) {
            su += a % 10;
            a /= 10;
        }
        return su;
    }

    public static boolean prime(int n) {
        if (n == 1) {
            return true;
        }

        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static boolean isvowel(char c) {
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y') {
            return true;
        } else {
            return false;
        }
    }

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

    static int gd(int a) {
        
        Set<Integer> q = new TreeSet();
        for (int i = 1; i<=Math.sqrt(a); ++i) {
            if (a%i==0) {
                q.add(i);
                q.add(a/i);
            }
        }
        return q.size();
    }

    static long sum(long n) {
        return n * (n + 1) / 2;
    }

    static int divisors(int n, int m) {
        if (n - (m + (m * m)) >= 0) {
            return m;
        }
        for (int i = (int) Math.sqrt(m); i >= 1; i--) {
            if (m % i == 0 && n - (m + (m * i)) >= 0) {
                return i;
            }
        }
        return 1;
    }

    static boolean cal(int val, int k, int t) {
        int res = val, p = 1;
        while (val / Math.pow(k, p) > 0) {
            res += val / Math.pow(k, p);
            p++;
        }
        return res >= t;
    }

    static int Last_Ocuu(int[] a, int n, long v) {
        int start = 0, end = n - 1, mid, ans = -1;

        while (start <= end) {
            mid = (start + end) >> 1;
            if (a[mid] < v) {
                ans = mid;
                end = mid - 1;
            } else if (a[mid] >= v) {
                //ans=mid;
                start = mid + 1;
            }

        }
        return ans;
    }

    static int Last_Ocuu(List<Long> a, int n, int i, long v) {
        int sta = 0, end = n - 1, ans = -1;
        while (sta <= end) {
            int mid = (sta + end) >> 1;
            if (a.get(mid) + a.get(i) >= v && mid != i) {
                ans = mid;
                end = mid - 1;
            } else {
                sta = mid + 1;
            }
        }
        return ans;
    }

    static long summtion(int[] a) {
        long s = 0;
        for (int i = 0; i < a.length; i++) {
            s += (long) a[i];
        }
        return s;
    }

    static boolean vv(int i, int j, int n, int m) {
        if (i >= 0 && i < n && j < m && j >= 0) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) throws IOException, ParseException {
        Scannerr in = new Scannerr(System.in);
        PrintWriter or = new PrintWriter(System.out);
        //   BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
          int n=in.nextInt();
          int b=in.nextInt();
          int c=in.nextInt();
          int[] a= new int[1234567];
          for (int i = 1; i <= 1000000; i++) {
              for (int j = i; j <= 1000000; j+=i) {
                  a[j]++;
              }
        }
          long ans=0;
          for (int i = 1; i <=n; i++) {
              for (int j = 1; j <=b; j++) {
                  for (int k = 1; k <=c; k++) {
                      ans+=a[i*j*k];         
                  }
              }
        }
          or.print(ans%1073741824);
        or.flush();
    }

    static class Scannerr {

        StringTokenizer st;
        BufferedReader br;

        public Scannerr(FileReader fileReader) throws FileNotFoundException {
            br = new BufferedReader(fileReader);
        }

        public Scannerr(InputStream s) throws FileNotFoundException {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public double nextDouble() throws IOException {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++) {
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec) {
                        f *= 10;
                    }
                }
            }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public boolean ready() throws IOException {
            return br.ready();
        }

    }

}

class Pair {

    int ind;
    int val;

    //int min;
    public Pair(int n, int p) {
        ind = n;
        val = p;
        // min = m;
    }

}