import java.util.*

fun main(args: Array<String>) {
    val pw = java.io.PrintWriter(System.out)
    Problem.solve(Scanner(System.`in`), pw)
    pw.flush()
}

object Primes : Iterable<Long> {
    private var checked = 2L
    private val xs = mutableListOf(2L)

    /**
     * Check if n is prime number.
     *
     * @param n number
     * @return true when n is prime number
     */
    fun contains(n: Long): Boolean {
        var i = xs.count()
        while (checked < n) get(i++)
        return xs.contains(n)
    }

    /**
     * Get i-th prime number.
     *
     * @param i index (0-)
     * @return i-th prime number
     */
    fun get(i: Int): Long {
        while (xs.count() <= i) {
            var n = checked + 1
            loop@ while (true) {
                for (j in xs) {
                    if (j * j > n) {
                        break@loop
                    }
                    if (n % j == 0L) {
                        n++
                        break
                    }
                }
            }
            xs.add(n)
            checked = n
        }
        return xs[i]
    }

    /**
     * Get iterator.
     *
     * @return iterator
     */
    override fun iterator(): Iterator<Long> = object : Iterator<Long> {
        var i = 0
        override fun hasNext(): Boolean = true
        override fun next(): Long {
            val x = get(i)
            i += 1;
            return x
        }
    }
}

// 素因数分解
fun factorize(n: Long): Map<Long, Int> {
    val result = mutableMapOf<Long, Int>()
    val it = Primes.iterator()
    var i = n
    do {
        val p = it.next()
        if ((i % p) == 0L) {
            var pn = 0
            do {
                pn++
                i /= p
            } while ((i % p) == 0L)
            result[p] = pn
        }
    } while (p * p <= i)
    if (i != 1L) {
        result[i] = 1
    }
    return result
}

object Problem {
    fun solve(sc: Scanner, pw: java.io.PrintWriter) {
        val N = sc.next().toLong()
        val f = factorize(N)
        var ans = 0L
        f.forEach {
            var n = it.value
            var i = 1
            while (n >= i) {
                n -= i
                ans++
                i += 1
            }
        }
        pw.println(ans)
    }
}
