CodeEff/ECCO huggingface dataset:
# Original solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

N = int(eval(input()))
flag = 0
if N == 1:
    flag = -1
M = len(factorization(N))
num = [1,3,6,10,15,21,28,36]
ans = 0
for i in range(M):
    for j in range(len(num)):
        if num[j] <= factorization(N)[i][1]:
            ans += 1

if flag == -1:
    print((0)) 
else:
    print(ans)

# Optimized solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

N = int(eval(input()))
flag = 0
if N == 1:
    flag = -1
M = len(factorization(N))
num = [1,3,6,10,15,21,28,36]
ans = 0
for i in range(M):
    for j in range(len(num)):
        if num[j] <= factorization(N)[i][1]:
            ans += 1
        else:
            break

if flag == -1:
    print((0)) 
else:
    print(ans)
# Original solution
import math

def isPrime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    elif num % 2 == 0:
        return False

    for i in range(3, math.floor(math.sqrt(num))+1, 2):
        if num % i == 0:
            return False
    return True


def find_all_prime(num):
    prime_list = [2]
    for i in range(3, num, 2):
        if isPrime(i):
            prime_list.append(i)

    return prime_list


if __name__ == "__main__":
    N = int(eval(input()))
    if isPrime(N):
        print((1))
    else:      
        prime_list = find_all_prime(int(1.25*10**6))
        count = 0  
        for i in prime_list:
            j = 1
            while N > 1:
                if N // i**j == 0:
                    break
                if N % i**j == 0:
                    N = N // i**j
                    count += 1
                j +=1
        
        print(count)

# Optimized solution
def factorization(n):
    factorization_list = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp % i == 0:
            count = 0
            while temp % i == 0:
                count += 1
                temp //= i
            factorization_list.append([i, count])

    if temp != 1:
        factorization_list.append([temp, 1])

    if factorization_list==[]:
        factorization_list.append([n, 1])

    return factorization_list


if __name__ == "__main__":
    N = int(eval(input()))

    if N == 1:
        print((0))

    else:
        factorization_list = factorization(N)
        count = 0
        for factor in factorization_list:
            e = factor[1]
            i = 1
            while True:
                e -= i
                i += 1
                count += 1
                if e < i:
                    break
        print(count)
# Original solution
from collections import Counter

n = int(eval(input()))

def primes(x):
   is_prime = [True] * (x+1)
   is_prime[0] = False
   is_prime[1] = False
   for i in range(2, int(x**0.5)+1):
      if not is_prime[i]:
         continue
      for j in range(i*2, x+1, i):
         is_prime[j] = False
   return [i for i in range(x+1) if is_prime[i]]

pl = primes(int(n**0.5)+1)

def factorization(x):
   arr = []
   tmp = x
   while x > 1:
      for i in pl:
         if x % i == 0:
            x /= i
            arr.append(i)
            break
      if x == tmp and len(arr) == 0:
         return [x]
   return arr

ans = 0
for k, v in list(Counter(factorization(n)).items()):
   i = 0
   while v > i:
      i += 1
      v -= i
      ans += 1
print(ans)


# Optimized solution
n = int(eval(input()))

from collections import Counter

factors = []
i = 2
while n > 1:
   if n < i * i:
      factors.append(n)
      break
   while n % i == 0:
      factors.append(i)
      n //= i
   i += 1

ans = 0
for cnt in list(Counter(factors).values()):
   i = 1
   while cnt >= i:
      cnt -= i
      i += 1
      ans += 1
print(ans)
# Original solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

n = int(eval(input()))
l = factorization(n)
ans = 0
for c in l:
    if c[0]==1:
        break
    lim = c[1]
    num = 1
    while lim >= num:
        lim -= num
        num += 1
    ans += num-1

print(ans)

# Optimized solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    return arr

n = int(eval(input()))
l = factorization(n)
ans = 0
for c in l:
    lim = c[1]
    num = 0
    while lim > num:
        num += 1
        lim -= num
    ans += num

print(ans)
# Original solution
n=int(eval(input()))
a=p=1
while p<6**8:
 c=t=0;p+=1
 while n%p<1:n//=p;x=c==t;t+=x;c+=1-t*x;a+=x
print((a-(n<2)))

# Optimized solution
n=int(eval(input()))
a=p=1
while p<1e6:
 c=t=0;p+=1
 while n%p<1:n//=p;x=c==t;t+=x;c+=1-t*x;a+=x
print((a-(n<2)))
# Original solution
N=int(eval(input()))
p_list=[]

if N%2==0:
  count=0
  while N%2==0:
    count+=1
    N/=2
  p_list.append([2,count])

i=3
while i<N**0.5+1:
  if N%i==0:
    count=0
    while N%i==0:
      count+=1
      N/=i
    p_list.append([i,count])
  i+=2

if N!=1:
  p_list.append([int(N),1])

result=0
for i in range(len(p_list)):
  j=1
  while p_list[i][1]>=j:
    p_list[i][1]-=j
    j+=1
    result+=1
print(result)

# Optimized solution
N=int(eval(input()))
p=[]
r=0

if N%2==0:
  c=0
  while N%2==0:
    c+=1
    N/=2
  p.append([c])
  
i=3
while i<N**0.5+1:
  if N%i==0:
    c=0
    while N%i==0:
      c+=1
      N/=i
    p.append([c])
  i+=2
  
if N!=1:
  p.append([1])
  
for i in range(len(p)):
  j=1
  while p[i][0]>=j:
    p[i][0]-=j
    j+=1
    r+=1
    
print(r)
# Original solution
N=int(eval(input()))
p=[]
r=0

if N%2==0:
  c=0
  while N%2==0:
    c+=1
    N/=2
  p.append(c)
  
for i in range(3,int(N**0.5)+1,2):
  if N%i==0:
    c=0
    while N%i==0:
      c+=1
      N/=i
    p.append(c)
  
if N!=1:
  p.append(1)
  
for i in p:
  r+=int(((8*i+1)**0.5-1)/2)
print(r)

# Optimized solution
N=int(eval(input()))
p=[]
r=0

if N%2==0:
  c=0
  while N%2==0:
    N=N//2
    c+=1
  p.append(c)
for i in range(3,int(N**0.5)+1,2):
  if N%i==0:
    c=0
    while N%i==0:
      N=N//i
      c+=1
    p.append(c)
if N!=1:
  p.append(1)
  
while p:
  r+=int(((8*p.pop()+1)**0.5-1)/2)
  
print(r)
# Original solution
n = int(eval(input()))
c = 0
for p in range(2, int(n**0.5)+1): #nが合成数
  e = 0
  while n%p == 0:
    n //= p
    e += 1
  i = 1
  while e >= i:
    e -= i
    c += 1
    i += 1
if n != 1: #nが素数
  c += 1
print(c)

# Optimized solution
n = int(eval(input()))
c = 0
for p in range(2, int(n**0.5)+1): #nが合成数
  e = 0
  while n%p == 0:
    n //= p
    e += 1
  i = 1
  while e >= i:
    e -= i
    c += 1
    i += 1
if n != 1: #nが素数 or nがn^0.5より大きい素数を因数に持つ合成数
  c += 1
print(c)
# Original solution
from math import sqrt

def is_prime(n):
  if n == 1:
    return False
  for i in range(2, int(sqrt(n))+1):
    if n % i == 0:
      return False
  return True

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(sqrt(n))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
        if len(arr) > 1:
          break

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

base=int(eval(input()))
tmp=base
num=[]
if is_prime(base):
  num.append(base)
else:
  for i in range(2, base+1):
    if i > tmp:
      break
    if tmp % i == 0 and len(factorization(i)) == 1:
      num.append(i)
      tmp/=i
print((len(num)))

# Optimized solution
from math import sqrt

def is_prime(n):
  if n == 1:
    return False
  for i in range(2, int(sqrt(n))+1):
    if n % i == 0:
      return False
  return True

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(sqrt(n))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
        if len(arr) > 1:
          break

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

base=int(eval(input()))
tmp=base
num=[]
if is_prime(base):
  num.append(base)
else:
  for i in range(2, base+1):
    if i > tmp:
      break
    if tmp % i == 0 and len(factorization(i)) == 1:
      num.append(i)
      tmp/=i
      if is_prime(tmp):
        num.append(tmp)
        break
print((len(list(set(num)))))
# Original solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

def readinput():
    n=int(eval(input()))
    return n

def possibleCnt(n):
    cnt=0
    resu=n
    for i in range(1,n+1):
        if resu >= i:
            cnt+=1
            resu-=i
            #print(cnt,resu)
    return cnt       

def main(n):
    ansList=factorization(n)
    #print(ansList)
    count=0
    for l in ansList:
        if(l[0]!=1):
            count+=possibleCnt(l[1])
    return count    


if __name__=='__main__':
    n=readinput()
    ans=main(n)
    print(ans)


# Optimized solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

import math
def myFactorization(n):
    '''nを素因数分解する

    戻り値: factList = [[prime1, exp1], [prime2, exp2],...] 
           n=(prime1)**exp1 * (prime2)**exp2 * ...
    '''

    factList=[]
    temp=n
    cnt=0
    while(temp%2==0):
        temp=temp//2
        cnt+=1
    if(cnt>0):
        factList.append([2,cnt])

    m=int(math.sqrt(n))+1
    for i in range(3,m+1,2):
        cnt=0
        while(temp%i==0):
            temp=temp//i
            cnt+=1
        if(cnt>0):
            factList.append([i,cnt])
        if(temp==1):
            break
    if(temp>1):
        factList.append([temp,1])
    return factList            


def readinput():
    n=int(eval(input()))
    return n

def possibleCnt(n):
    cnt=0
    resu=n
    for i in range(1,n+1):
        if resu >= i:
            cnt+=1
            resu-=i
            #print(cnt,resu)
    return cnt       

def main(n):
    #ansList=factorization(n)
    ansList=myFactorization(n)
    #print(ansList)
    count=0
    for l in ansList:
        if(l[0]!=1):
            count+=possibleCnt(l[1])
    return count    


if __name__=='__main__':
    n=readinput()
    ans=main(n)
    print(ans)
# Original solution
from collections import Counter

N = int(eval(input()))

n = N
counter = Counter()
while n % 2 == 0:
    counter[2] += 1
    n //= 2
p = 3
while p ** 2 <= N:
    if n % p == 0:
        counter[p] += 1
        n //= p
    else:
        p += 2
if n != 1:
    counter[N] += 1

ans = 0
for key in list(counter.keys()):
    e = 1
    while counter[key] >= e:
        ans += 1
        counter[key] -= e
        e += 1

print(ans)


# Optimized solution
from collections import Counter


def prime_factorization(n):
    counter = Counter()
    max_pp = n
    while n % 2 == 0:
        counter[2] += 1
        n //= 2
    p = 3
    while p ** 2 <= max_pp:
        if n % p == 0:
            counter[p] += 1
            n //= p
        else:
            p += 2
    if n != 1:
        counter[n] += 1
    return counter


N = int(eval(input()))
prime_counter = prime_factorization(N)
ans = 0
for key in list(prime_counter.keys()):
    for e in range(1, N):
        if prime_counter[key] >= e:
            prime_counter[key] -= e
            ans += 1
            e += 1
        else:
            break

print(ans)
# Original solution
import sys
from bisect import bisect

def solve():
    input = sys.stdin.readline
    N = int(eval(input()))
    A = [int(i) + 1 for i in range(40)]
    B = [0] * 41
    for i, a in enumerate(A):
        B[i+1] = B[i] + a
    count = 0
    k = N
    for i in range(2, N+1):
        if i ** 2 > N: break
        if N % i == 0:
            d = 0
            while k % i == 0:
                d += 1
                k //= i
            count += bisect(B, d) - 1
    if k > 1: count += 1
    print(count)

    return 0

if __name__ == "__main__":
    solve()

# Optimized solution
import sys
from bisect import bisect

def solve():
    input = sys.stdin.readline
    N = int(eval(input()))
    sum = [0] * 41
    for i in range(1, 41):
        sum[i] = sum[i-1] + i
    count = 0
    k = N
    for i in range(2, N + 1):
        if i ** 2 > k: break
        if k % i == 0:
            d = 0
            while k % i == 0:
                d += 1
                k //= i
            count += bisect(sum, d) - 1
    if k > 1: count += 1
    print(count)

    return 0

if __name__ == "__main__":
    solve()
# Original solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
  
n = int(eval(input()))

fact = factorization(n)
cnt = 0
for f in fact:
  if f[0] == 1:
    continue
  i = 1
  while True:
    f[1] -= i
    i += 1
    if f[1] < 0:
      break
    cnt += 1
print(cnt)

# Optimized solution
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr
  
n = int(eval(input()))

fact = factorization(n)
cnt = 0
for f in fact:
  if f[0] == 1:
    continue
  i = 1
  while True:
    f[1] -= i
    i += 1
    if f[1] < 0:
      break
    cnt += 1
print(cnt)
# Original solution
N = int(eval(input()))
A = [0 for k in range(int(N**0.5)+1)]

#N=1の処理
if N == 1:
  print((0))
  exit()
ans = 0


prime = [2]
for k in range(3, len(A), 2):
  if A[k] == 0:
    prime.append(k)
    for j in range(k, len(A), k):
      A[j] = 1
for p in prime:
  if N%p == 0:
    break
else: 
  print((1))
  exit()

used = []
use = []
#print(prime)
for p in prime:
  if p > N:
    break
  if N%p == 0:
    #print(p)
    ans += 1
    used.append(p)
    use.append(p)
    N = N // p
  np = p * p
  while N % np == 0:
    #print(np)
    ans += 1
    used.append(np)
    N = N // np
    np = np * p
    
#print(use)
#print(N)

for u in used:
  if N % u == 0:
    N = N // u
for u in used:
  if N % u == 0:
    N = N // u
for u in used:
  if N % u == 0:
    N = N // u
if N > 1:
  ans += 1
print(ans)    

# Optimized solution
N = int(eval(input()))
A = [0 for k in range(int(N**0.5)+1)]

#N=1の処理
if N == 1:
  print((0))
  exit()
ans = 0


prime = [2]
for k in range(3, len(A), 2):
  if A[k] == 0:
    prime.append(k)
    for j in range(k, len(A), k):
      A[j] = 1
for p in prime:
  if N%p == 0:
    break
else: 
  print((1))
  exit()

use = []
for p in prime:
  if p > N:
    break
  if N%p == 0:
    ans += 1
    use.append(p)
    N = N // p
  np = p * p
  while N % np == 0:
    ans += 1
    N = N // np
    np = np * p
    
for u in use:
  while N % u == 0:
    N = N // u
if N > 1:
  ans += 1
print(ans)
# Original solution
n = int(eval(input()))

def prime_factor(n):
	factor = []
	for i in range(2, int(n ** 0.5) + 1):
		while (n % i == 0):
			factor.append(i)
			n //= i
	if n != 1:
		factor.append(n)
	return factor

from collections import Counter

f = prime_factor(n)
c = Counter(f)
res = 0
for k, v in list(c.items()):
    num = c[k] # 指数
    i = 1
    while num >= i:
        num -= i
        res += 1
        i += 1

print(res)

# Optimized solution
from collections import Counter

n = int(eval(input()))

def prime_factor(n):
	factor = []
	for i in range(2, int(n ** 0.5) + 1):
		while (n % i == 0):
			factor.append(i)
			n //= i
	if n != 1:
		factor.append(n)
	return factor

factor = prime_factor(n)
c = Counter(factor)

cnt = 0
for k, v in list(c.items()):
    num, idx = 1, 1
    while num <= v:
        cnt += 1
        idx += 1
        num += idx

print(cnt)
# Original solution
from collections import Counter

n = int(eval(input()))

def prime_factor(n):
	factor = []
	for i in range(2, int(n ** 0.5) + 1):
		while (n % i == 0):
			factor.append(i)
			n //= i
	if n != 1:
		factor.append(n)
	return factor

factor = prime_factor(n)
c = Counter(factor)

cnt = 0
for k, v in list(c.items()):
    num, idx = 1, 1
    while num <= v:
        cnt += 1
        idx += 1
        num += idx

print(cnt)

# Optimized solution
n = int(eval(input()))

def prime_factor(n):
    factor = []
    for i in range(2, int(n ** 0.5) + 1):
        while (n % i == 0):
            factor.append(i)
            n //= i
    if n != 1:
        factor.append(n)
    return list(set(factor))

factor = prime_factor(n)

cnt = 0
for p in factor:
    if n % p == 0:
        e = 1
        while n % pow(p, e) == 0:
            cnt += 1
            n //= pow(p, e)
            e += 1

print(cnt)
# Original solution
from heapq import heappop, heappush
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def prime_factorization(n):
    d = {}
    i = 2
    while i * i <= n:
        if n % i == 0:
            d[i] = 1
            n //= i
            while n % i == 0:
                n //= i
                d[i] += 1
        i += 1
    if n > 1:
        d[n] = 1
    return d

def main():
    N = int(readline())

    d = prime_factorization(N)
    queue = []
    for k, v in list(d.items()): 
        for i in range(1, v+1):
            heappush(queue, (pow(k, i), k, i))
    
    cnt = dict()
    ans = 0
    while queue:
        z, p, e = heappop(queue)
        if p in cnt:
            if cnt[p] + e <= d[p]:
                cnt[p] += e
                ans += 1
            else:
                continue
        else:
            cnt[p] = e
            ans += 1

    print(ans)


if __name__ == "__main__":
    main()


# Optimized solution
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def prime_factorization(n):
    d = {}
    i = 2
    while i * i <= n:
        if n % i == 0:
            d[i] = 1
            n //= i
            while n % i == 0:
                n //= i
                d[i] += 1
        i += 1
    if n > 1:
        d[n] = 1
    return d

def main():
    N = int(readline())

    d = prime_factorization(N)
    
    ans = 0
    for k, v in list(d.items()):
        e = 0
        for i in range(1, v+1):
            e += i
            if e > v:
                break
            ans += 1

    print(ans)


if __name__ == "__main__":
    main()
# Original solution
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,copy
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

#素因数分解
def prime_factorize(n):
    if n == 1:
        return [1]
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a
n = inp()
if n == 1:
    print((0))
    quit()
c = Counter(prime_factorize(n))
res = 0
for key in list(c):
    va = c[key]
    cnt = 0
    for i in range(1,100000):
        cnt += i
        if va < cnt:
            res += i-1
            break
print(res)

# Optimized solution
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

#素因数分解
def prime_factorize(n):
    if n == 1:
        return [1]
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2
    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2
    if n != 1:
        a.append(n)
    return a
n = inp()
c = Counter(prime_factorize(n))
res = 0
# print(c)
for k,v in list(c.items()):
    if k == 1: continue
    cnt = 0
    for now in range(1,150000):
        cnt += now
        if cnt > v:
            res += now-1
            break
print(res)
# Original solution
import math
def solve():
    N = int(eval(input()))
    divisors = calc_divisors(N)
    divisors.sort()

    now = N
    i = 1
    ans = 0
    while i != len(divisors):
        if isPrime(divisors[i]) and now % divisors[i] == 0:
            now /= divisors[i]
            ans += 1
        else:
            if len(set(prime_factorize(divisors[i]))) == 1 and now % divisors[i] == 0:
                now /= divisors[i]
                ans += 1
        i += 1
    
    print(ans)

def isPrime(n):
    if n == 1: return False

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False

    return True

def sieve(n):
    is_prime = [True] * (n+1)
    is_prime[0] = False
    is_prime[1] = False

    p = 0
    for i in range(2,n+1):
        if is_prime[i]:
            p = i
            for j in range(p+p, n+1, p):
                is_prime[j] = False
        
        if p * p > n:
            break
    
    primes = []
    for i in range(2,n+1):
        if is_prime[i]:
            primes.append(i)

    return primes

def prime_factorize(n):
    prime_numbers = []
    for p in range(2, int(math.sqrt(n)+1)):
        if n % p != 0:
            continue
        while n % p == 0:
            n /= p
            prime_numbers.append(p)

    if n != 1:
        prime_numbers.append(n)
    return prime_numbers

def calc_divisors(n):
    divisors = []
    for i in range(1,int(math.sqrt(n)+1)):
        if n % i == 0:
            divisors.append(i)
            if (i*i != n):
                divisors.append(n//i)

    return divisors
if __name__ == '__main__':
    solve()

# Optimized solution
import math
from collections import Counter
def solve():
    N = int(eval(input()))
    primeFac = prime_factorize(N)
    counter = Counter(primeFac)
    divisors = []
    for key, val in list(counter.items()):
        for i in range(1,val+1):
            divisors.append(pow(key,i))

    divisors.sort()
    now = N
    ans = 0
    for d in divisors:
        if now % d == 0:
            ans += 1
            now //= d
    
    print(ans)

def prime_factorize(n):
    prime_numbers = []
    for p in range(2, int(math.sqrt(n)+1)):
        if n % p != 0:
            continue
        while n % p == 0:
            n /= p
            prime_numbers.append(p)

    if n != 1:
        prime_numbers.append(n)
    return prime_numbers
    
if __name__ == '__main__':
    solve()