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: Accepted)

import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Text.Read as T
import Data.List (unfoldr)
import Data.Maybe (catMaybes)

main :: IO ()
main = do
  let
    primeFactors :: Int -> [Int]
    primeFactors = catMaybes . unfoldr next . (,) 2
      where
        next :: (Int, Int) -> Maybe (Maybe Int, (Int, Int))
        next (_, 1)             = Nothing
        next (d, m) | m < d * d = Just (Just 1, (0, 1))
                    | otherwise = Just $ (,) (succ d) <$> ord d m
        ord :: Int -> Int -> (Maybe Int, Int)
        ord d = go 0
          where
            go :: Int -> Int -> (Maybe Int, Int)
            go c m | r == 0 = go (succ c) m'
              where
                (m', r) = m `divMod` d
            go 0 m = (Nothing, m)
            go c m = (Just c, m)
    f :: Int -> Int
    f m = unsafeBinaryMaxInt p (1, 8)
      where
        unsafeBinaryMaxInt :: (Int -> Bool) -> (Int, Int) -> Int
        unsafeBinaryMaxInt p = check
          where
            check :: (Int, Int) -> Int
            check ij@(_, j) | p j       = j
                            | otherwise = search ij
            search :: (Int, Int) -> Int
            search = fst . until ((==) <$> fst <*> pred . snd) halve
              where
                halve :: (Int, Int) -> (Int, Int)
                halve (i, j) | p m       = (m, j)
                             | otherwise = (i, m)
                  where
                    m = (i + j) `div` 2
        p :: Int -> Bool
        p = (<= 2 * m) . ((*) <$> id <*> succ)
  n <- unsafeTextToInt <$> T.getLine :: IO Int
  print . sum . map f . primeFactors $ n

unsafeTextToInt :: T.Text -> Int
unsafeTextToInt s = case T.signed T.decimal s of
  Right (n, _) -> n
{-# INLINE unsafeTextToInt #-}