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 Common Lisp (SBCL 2.0.3) (judge verdict: Time Limit Exceeded)

(defun barasu (n &optional (acc 1))
  (cond ((= n acc)
         acc)
        ((< n acc)
         (1- acc))
        (t 
         (barasu (- n acc) (1+ acc)))))      

(defun main (n)
  (let ((p-list '(2))
        (p 2)
        (d-list (list 0)))
    (labels ((next-prime! (num)
               (let ((next (1+ num))
                     (can-div nil))
                 (loop :named xxx
                       :for q :in p-list
                       :do (when (= (mod next q) 0)
                             (setf can-div t)
                             (return-from xxx)))
                 (cond (can-div
                        (next-prime! next))
                       (t
                        (setf p next)
                        (push next p-list))))))
      ;;
      (loop :named yyy
            :do (cond ((= n 1)
                       (return-from yyy))
                      ((and (/= n p) (> p (sqrt n)))
                       (push 1 d-list)
                       (return-from yyy))
                      ((= (mod n p) 0)
                       (setf n (/ n p))
                       (incf (car d-list)))
                      (t
                       (push 0 d-list)
                       (next-prime! p))))
      ;;
      (loop :for d :in d-list :sum (barasu d)))))

(let ((n (read)))
  (format t "~A~%" (main n)))