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 Kotlin (1.3.71) (judge verdict: Wrong Answer)

import java.lang.Math.*
import kotlin.math.pow
import kotlin.math.sqrt

fun main(args: Array<String>) {
    val n = readLong()
    var cnt = 0
    var soinsu = mutableListOf<Long>()
    var divs = mutableSetOf<Long>()

    var a = n
    for (i in 2 .. sqrt(n.toDouble()).toLong()) {
        while (a % i == 0L) {
            soinsu.add(i)
            divs.add(i)
            a /= i
        }
    }

    if (a > 1) {
        soinsu.add(n)
        divs.add(n)
    }

    var b = n
    for (i in  divs) {
        var z = i
        val count = soinsu.count{ it == i}
        for (j in 1 .. count) {
            if (b % z == 0L) {
                cnt++
                b /= z
                z *= i
            } else {
                break
            }
        }
    }
//    for (i in divs) {
//        var z = i
//        val count = soinsu.count{ it == i}
//        for (j  in 1 .. count) {
//            cnt++
//            b /= z
//            z *= i
//            if (z > b)
//        }
//    }

    println(cnt)

}

private fun myPow(a:Long, b:Int): Long {
    var x = a
    for (i in 1 until  b) {
        x *= a
    }
    return x
}

private fun read() = readLine()!!

private fun readInt() = read().toInt()

private fun readLong() = read().toLong()

private fun readDouble() = read().toDouble()

private fun readListString() = read().split(" ")

private fun readListInt() = readListString().map { it.toInt() }

private fun readListLong() = readListString().map { it.toLong() }

private fun readListDouble() = readListString().map { it.toDouble() }

private fun readMatrixString(n: Int): List<List<String>> {
    val matrix = mutableListOf<List<String>>()
    for (i in 0 until n) {
        val list = readListString()
        matrix.add(list)
    }
    return matrix
}

private fun readMatrixInt(n: Int): List<List<Int>> {
    val matrix = mutableListOf<List<Int>>()
    for (i in 0 until n) {
        val list = readListInt()
        matrix.add(list)
    }
    return matrix
}

private fun readMatrixDouble(n: Int): List<List<Double>> {
    val matrix = mutableListOf<List<Double>>()
    for (i in 0 until n) {
        val list = readListDouble()
        matrix.add(list)
    }
    return matrix
}

private fun readMatrixLong(n: Int): List<List<Long>> {
    val matrix = mutableListOf<List<Long>>()
    for (i in 0 until n) {
        val list = readListLong()
        matrix.add(list)
    }
    return matrix
}