Problem:
Score : 400 points

Problem Statement

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.

Sample Input 1

24

Sample Output 1

3

We can apply the operation three times by, for example, making the following choices:

Choose z=2 (=2^1). (Now we have N=12.)

Choose z=3 (=3^1). (Now we have N=4.)

Choose z=4 (=2^2). (Now we have N=1.)

Sample Input 2

1

Sample Output 2

0

We cannot apply the operation at all.

Sample Input 3

64

Sample Output 3

3

We can apply the operation three times by, for example, making the following choices:

Choose z=2 (=2^1). (Now we have N=32.)

Choose z=4 (=2^2). (Now we have N=8.)

Choose z=8 (=2^3). (Now we have N=1.)

Sample Input 4

1000000007

Sample Output 4

1

We can apply the operation once by, for example, making the following choice:

z=1000000007 (=1000000007^1). (Now we have N=1.)

Sample Input 5

997764507000

Sample Output 5

7

Solution in PyPy3 (7.3.0) (judge verdict: Accepted)

#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    def is_p(n):
        if n < 4:
            return 1
        i = 2
        while i*i <= n:
            if n%i == 0:
                return 0
            i += 1
        return 1

    def f(n):
        res = set([n])
        i = 2
        while i*i <= n:
            if n%i == 0:
                m = n//i
                res.add(i)
                res.add(m)
            i += 1
        res = list(res)
        res.sort()
        return res

    n = I()
    if n == 1:
        print(0)
        return
    if is_p(n):
        print(1)
        return
    f = f(n)
    m = len(f)
    k = [0]*m
    for i in range(m):
        fi = f[i]
        if is_p(fi):
            for j in range(i+1,m):
                if f[j]%fi == 0:
                    k[j] += 1
    lis = deque([f[i] for i in range(m) if k[i] <= 1])
    ans = 0
    while lis:
        x = lis.popleft()
        if n%x == 0:
            n //= x
            ans += 1
    print(ans)
    return

#Solve
if __name__ == "__main__":
    solve()