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 Haskell (GHC 8.8.3) (judge verdict: Wrong Answer)

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MultiWayIf #-}


import Control.Arrow
import Control.Concurrent
import Control.Monad
import qualified Data.ByteString.Char8 as C
import Data.Complex
import Data.Function
import Data.Function.HT
import qualified Data.IntMap.Strict as IM
import qualified Data.IntSet as IS
import Data.List
import Data.Ord
import qualified Data.Sequence as Sq
import Data.Vector.Algorithms.Search
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as UM
import Debug.Trace


------------------
-- #   Read   # --
------------------

r :: Int -> IO (U.Vector Int)
r n = U.unfoldrN n (C.readInt . C.dropWhile (==' ')) <$> C.getLine

r' :: IO [Int]
r'  =   unfoldr    (C.readInt . C.dropWhile (==' ')) <$> C.getLine




main = do
    n <- readLn :: IO Int
    print $ solve n

solve2 n = sum $ map (findG.snd) $ pfacTup n


solve n = solveAux n (fac2 2 n) 0

solveAux n [] ac = ac
solveAux n (x:xs) ac =
    -- traceShow (n,x,ac)$ 
    solveAux (n `div` x) (fac2 (x+1) (n `div` x)) (ac + 1)

findG n = head $ dropWhile (\x->g x<n) [1..]

fac :: Int -> Int -> [Int]
fac st n = filter ((==0) . (n `rem`)) [st..floor(sqrt $ fromIntegral n)]

fac2 st n = (fac st n) ++ dropWhile (<st) (reverse (map (n`div`) (fac 1 n)))


facW n = case pfacTup n of  [] -> [(n,1)]
                            xs -> xs

pfacTup n = fAux (takeWhile (<(ceiling(sqrt (fromIntegral n)))) primes) n where
    fAux    _     1 = []
    fAux [] n = []
    fAux q@(p:ps) n = if n`rem`p==0
        then let e = head (dropWhile (\x-> n`rem`(p^x) == 0 ) [1..])-1
            in (p,e):(fAux q (n`quot`(p^e)))
        else fAux ps n
g n = n * (n+1) `div` 2

pfac = fAux primes where
    fAux    _     1 = []
    fAux q@(p:ps) n = if n`rem`p==0 then p:(fAux q (n`quot`p)) else fAux ps n

primes = f [2..] where f (p:ps) = p:(filter ((/=0).(`rem`p)) ps)