Given is a positive integer N. Consider repeatedly applying the operation below on N:

* First, choose a positive integer z satisfying all of the conditions below:
* z can be represented as z=p^e, where p is a prime number and e is a positive integer;
* z divides N;
* z is different from all integers chosen in previous operations.
* Then, replace N with N/z.



Find the maximum number of times the operation can be applied.

Constraints

* All values in input are integers.
* 1 \leq N \leq 10^{12}

Input

Input is given from Standard Input in the following format:


N


Output

Print the maximum number of times the operation can be applied.

Examples

Input

24


Output

3


Input

1


Output

0


Input

64


Output

3


Input

1000000007


Output

1


Input

997764507000


Output

7
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner stdIn = new Scanner(System.in);


		Map<Long,Integer> factMap = factorization(stdIn.nextLong());
		stdIn.close();

		if(factMap.isEmpty()) { //1のとき
			System.out.println(0);
			return;
		}

		int cnt = 0;
		for (Entry<Long, Integer> e : factMap.entrySet()) {
			cnt += countMin(e.getValue());
		}

		System.out.println(cnt);

	}

	private static Map<Long, Integer> factorization(long n) {
		Map<Long, Integer> factMap = new LinkedHashMap<Long, Integer>();

		while (n != 1) {
			if (n % 2 == 0) {
				factMap.putIfAbsent(2L, 0);
				factMap.replace(2L, factMap.get(2L) + 1);
				n /= 2;
				continue;
			}

			long d = 3;
			while (true) {

				if(d * d == n) {
					factMap.putIfAbsent(d, 0);
					factMap.replace(d, factMap.get(d) + 2);
					n = 1;
					break;
				}

				if (d * d >= n) {
					factMap.put(n, 1);
					n = 1;
					break;
				}

				if(n % d == 0) {
					factMap.putIfAbsent(d, 0);
					factMap.replace(d, factMap.get(d) + 1);
					n /= d;
					continue;
				}

				d += 2;
			}

		}

		return factMap;
	}

	private static int countMin(int pow) {
		return (int) Math.floor((Math.sqrt(2*pow + 0.25) - 0.5));

	}
}