package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

var pows map[int64]int64

func main() {
	sc.Buffer(make([]byte, 0), 1e6) // maxTokenSize
	sc.Split(bufio.ScanWords)
	defer out.Flush()
	/* --- code --- */

	pows = map[int64]int64{}
	N := nextInt64()
	// N := int64(24)
	CalcPrimes(N)
	ans := int64(0)
	for _, power := range pows {
		c := calcCombination(power)
		// fmt.Println(prime, power, c)
		ans += c

	}
	// for i := 0; i < len(primes); i++ {
	// 	prime := primes[i]
	// 	power := pows[prime]
	// 	c := calcCombination(power)
	// 	fmt.Println(prime, power, c)
	// 	ans += c
	// }
	fmt.Println(ans)

}

func calcCombination(n int64) int64 {
	ans := int64(0)
	sum := int64(0)
	for i := int64(1); i < n*n; i++ {
		sum += i
		if sum > n {
			return ans
		}
		ans++
	}
	return 1
}

func sqrtint64(x int64) int64 {
	if x == 0 {
		return 0
	}
	var left, right, ans int64
	left, right, ans = 1, x, 0
	for left <= right {
		mid := left + (right-left)/2
		if mid <= x/mid {
			left = mid + 1
			ans = mid
		} else {
			right = mid - 1
		}
	}
	return ans
}

func powint64(x int64, y int64) int64 {
	ans := int64(1)
	for i := int64(0); i < y; i++ {
		ans *= x
	}
	return ans
}

// GetBitLength ...
func GetBitLength(n int64, max int64) int64 {
	for i := int64(1); i < max; i++ {
		if n <= powint64(2, i) {
			return i
		}
	}
	return -1
}

// CalcPrimes ...
func CalcPrimes(n int64) []int64 {
	// 素因数を格納する配列
	results := make([]int64, 0)

	max := int64(sqrtint64(n)) + 1

	// 2 で割っていく
	for n%2 == 0 {
		results = append(results, 2)
		_, ok := pows[2]
		if !ok {
			pows[2] = 0
		}
		pows[2]++
		n /= int64(2)
	}

	// 3 で割っていく
	for n%3 == 0 {
		results = append(results, 3)
		_, ok := pows[3]
		if !ok {
			pows[3] = 0
		}
		pows[3]++
		n /= int64(3)
	}

	flag := true
	// 5 ～ math.sqrt(n) の数字で割っていく
	for num := int64(5); num < max; {
		for n%num == 0 {
			results = append(results, num)
			_, ok := pows[num]
			if !ok {
				pows[num] = 0
			}
			pows[num]++
			n /= num
			if n == 1 {
				return results
			}
		}

		if flag {
			num += 2
		} else {
			num += 4
		}
		flag = !flag
	}

	if n != 1 {
		results = append(results, n)
		_, ok := pows[n]
		if !ok {
			pows[n] = 0
		}
		pows[n]++
	}

	return results
}

// -*-*-*-*-*-*-*-*-
// * I/O utilities *
// -*-*-*-*-*-*-*-*-

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	a, _ := strconv.Atoi(next())
	return a
}

func nextInt64() int64 {
	a, _ := strconv.ParseInt(next(), 10, 64)
	return a
}

func nextFloat64() float64 {
	a, _ := strconv.ParseFloat(next(), 64)
	return a
}

func nextInts(n int) []int {
	ret := make([]int, n)
	for i := 0; i < n; i++ {
		ret[i] = nextInt()
	}
	return ret
}
func nextFloats(n int) []float64 {
	ret := make([]float64, n)
	for i := 0; i < n; i++ {
		ret[i] = nextFloat64()
	}
	return ret
}
func nextStrings(n int) []string {
	ret := make([]string, n)
	for i := 0; i < n; i++ {
		ret[i] = next()
	}
	return ret
}

func split(s string) []string {
	ret := make([]string, len([]rune(s)))
	for i, v := range []rune(s) {
		ret[i] = string(v)
	}
	return ret
}

// -*-*-*-*-*-*-*-*-
// * tool snippets *
// -*-*-*-*-*-*-*-*-
func duplicate2Int(base [][]int) (ret [][]int) {
	ret = make([][]int, len(base))
	for i, v := range base {
		ret[i] = append([]int{}, v...)
	}
	return
}

func max(a, b int) int {
	return int(max64(int64(a), int64(b)))
}

func max64(a int64, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func min(a, b int) int {
	return int(min64(int64(a), int64(b)))
}

func min64(a int64, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
// * math flavor typical theories *
// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
func gcd(a, b int) int {
	if a > b {
		return gcd(b, a)
	}
	for a != 0 {
		a, b = b%a, a
	}
	return b
}

func pow(a, b int) (ret int) {
	ret = a
	for i := 0; i < b-1; i++ {
		ret *= a
	}
	return
}

func powMod(n, m, mod int) (ret int) {
	ret = 1
	for m > 0 {
		if m&1 == 1 {
			ret *= n
			ret %= mod
		}
		n *= n
		n %= mod
		m >>= 1
	}
	return ret
}


Measured memory_bytes: 1768