CodeEff/ECCO huggingface dataset:
# Original solution
import itertools
import math
import fractions
import functools
import copy
from collections import deque
from functools import reduce
from decimal import Decimal

n = int(eval(input()))
prime = {}

num = n
i = 2
while True:
    if i * i > n:
        if(num > 1):
            prime[num] = 1
        break
    while num%i == 0:
        prime[i] = prime.get(i, 0) + 1
        num = num//i
    i += 1

count = 0
for val in list(prime.values()):
    use = 1
    while True:
        if(val < use):
            break
        val -= use
        use += 1
        count+=1
print(count)


# Optimized solution
import itertools
import math
import fractions
import functools
import copy
from collections import deque
from functools import reduce
from decimal import Decimal

n = int(eval(input()))

def how_many_prime(n):
    prime = {}
    num = n
    i = 2
    while True:
        if i * i > n:
            if(num > 1):
                prime[num] = 1
            break
        while num % i == 0:
            prime[i] = prime.get(i, 0) + 1
            num = num//i
        i += 1
    return prime

prime = how_many_prime(n)

count = 0
for val in list(prime.values()):
    use = 1
    while True:
        if(val < use):
            break
        val -= use
        use += 1
        count += 1
print(count)
# 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()))

count = 0
a = factorization(n)
if n == 1:
  print((0))
  exit()
  
for i in range(len(a)):
  a[i][1] -= 1
  count += 1
  count_n = 2
  while a[i][1] > 0:
    a[i][1] -= count_n
    if a[i][1] >= 0:
      count += 1
    count_n += 1

print(count)


# 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()))
 
count = 0
a = factorization(n)
if n == 1:
  print((0))
  exit()
  
for i in range(len(a)):
  a[i][1] -= 1
  count += 1
  b = 2
  while a[i][1] > 0:
    a[i][1] -= b
    if a[i][1] >= 0:
      count += 1
    b += 1
 
print(count)
# Original solution
def factorization(n):
    m=n
    counter_map={}
    i=2
    tmp=1
    while n!=1:
        #因数に持つか判定
        if n%i==0:
            n=n//i
            #素数判定
            for j in range(2,int(i**(1/2))+1):
                if i%j==0:
                    break
            else:
                tmp*=i
                if i not in counter_map:
                    counter_map[i]=1
                    tmp=1
                else:
                    if tmp not in counter_map:
                        counter_map[tmp]=1
                        tmp=1
        else:
            i+=1
            tmp=1
        if i>int(m**(1/2)) and n!=1:
            counter_map[n]=1
            break
        #print(i,n,counter_map)
    return counter_map


a=int(eval(input()))
b=factorization(a)
#print(b)

print((len(b)))


# Optimized solution
def factorization(n):
    m=n
    counter_map={}
    i=2
    tmp=1
    while n!=1:
        #因数に持つか判定
        if n%i==0:
            n=n//i
            #素数判定
            for j in range(2,int(i**(1/2))+1):
                if i%j==0:
                    break
            else:
                tmp*=i
                if i not in counter_map:
                    counter_map[i]=1
                    tmp=1
                else:
                    if tmp not in counter_map:
                        counter_map[tmp]=1
                        tmp=1
        else:
            i+=1
            tmp=1
        if i>int(m**(1/2)) and n!=1:
            counter_map[n]=1
            break
    return counter_map


a=int(eval(input()))
b=factorization(a)
sum=0

for i in list(b.keys()):
    counter=0
    for j in range(1,41):
        if b[i]>=1+(j+2)*(j-1)//2:
            counter=j
        else:
            break
    sum+=counter

print(sum)
# Original solution
def era(num):
    input_list = [False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(num)]
    input_list[0] = input_list[1] = False
    input_list[2] = input_list[3] = input_list[5] = True
    sqrt = num**0.5

    for serial in range(3, num, 2):

        if serial >= sqrt:
            return input_list

        for s in range(serial ** 2, num, serial): 
            input_list[s] = False

N=int(eval(input()))
if N<25:
    Prime=[2,3,5]
else:
    input_list=era(int(N**0.5)+1)
    Prime=[i for i, b in enumerate(input_list) if b == True]

Fac={}
for p in Prime:
    while N%p==0:
        N//=p
        if p in Fac:
            Fac[p]+=1
        else:
            Fac[p]=1
    if N==1:
        break
if N!=1:
    Fac[N]=1
ans=0

for k in Fac:
    nec=1
    while True:
        if Fac[k]>=nec:
            ans+=1
            Fac[k]-=nec
            nec+=1
        else:
            break

print(ans)

# Optimized solution
N=int(eval(input()))
F={}
for i in range(2,int(N**0.5)+1):
    if N%i==0:
        F[i]=1
        N//=i
    while N%i==0:
        N//=i
        F[i]+=1
if N>1:
    F[N]=1

ans=0
for f in F:
    j=1
    while True:
        F[f]-=j
        j+=1
        if F[f]>=0:
            ans+=1
        else:
            break
print(ans)
# Original solution

K = int(eval(input()))

N = 10**6
dp = [1] * (N+1)
dp[0] =  dp[1] =  0

def pw(j,i):
    while(j%i==0):
        j //= i
        
    if j == 1:
        return True
    else:
        return False

for i in range(2,N+1):
    if dp[i]:
        for j in range(i*i, N+1, i):
            #if not pw(j,i):
            dp[j] = 0
ans = 0
for n in range(N):
    i = 0
    while(1):
        i+=1
        v = pow(n,i)
        if (dp[n] == 1 and K%v==0):
            K //= v
            ans += 1
        else:
            break

for n in range(N):
    while(dp[n] == 1 and K%n==0):
        K //= n

#print (K)
if K!=1:
    ans += 1
print (ans)





# Optimized solution
N = int(eval(input()))
def factorize(N):
    n = N
    r = []
    for i in range(2,int(N**0.5)+1): # intに変換すること
        cnt = 0
        while(n%i==0):
            cnt += 1
            n //= i #  整数除算(//)を使うこと
        if cnt!=0:
            r.append((i,cnt))
    if n!=1:
        r.append((n,1))
    return r

ans = 0
for _, cnt in factorize(N):
    i = 1
    while(i <= cnt):
        cnt-=i
        i+=1
        ans+=1
print (ans)
# Original solution
def is_prime(num:int):
    if num == 1:
        return False
    elif num == 2:
        return True
    elif num % 2 == 0:
        return False

    r_num = int(num ** 0.5)
    for i in range(3, r_num + 1, 2):
        if num % i == 0:
            return False
    return True


def main():
    n = int(eval(input()))

    if n == 1:
        print((0))
        return

    cnt = 0
    r_n = int(n ** 0.5)
    for i in range(2, n):
        if n < i:
            break
        elif cnt == 0 and r_n+1 < i:
            break
        if n % i == 0 and is_prime(i):
            n = int(n/i)
            cnt += 1
            x = 2
            while True:
                q = i ** x
                if q > n:
                    break

                if n % q == 0:
                    n = int(n/q)
                    x += 1
                    cnt += 1
                else:
                    break

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


main()


# Optimized solution
def is_prime(num:int):
    if num == 1:
        return False
    elif num == 2:
        return True
    elif num % 2 == 0:
        return False

    r_num = int(num ** 0.5)
    for i in range(3, r_num + 1, 2):
        if num % i == 0:
            return False
    return True


def main():
    n = int(eval(input()))

    if n == 1:
        print((0))
        return

    cnt = 0
    r_n = int(n ** 0.5)
    divided = []
    for i in range(2, n):
        if n < i:
            break
        elif cnt == 0 and r_n+1 < i:
            break
        if n % i == 0 and is_prime(i):
            n = int(n/i)
            divided.append(i)
            cnt += 1
            x = 2
            while True:
                q = i ** x
                if q > n:
                    break

                if n % q == 0:
                    n = int(n/q)
                    x += 1
                    cnt += 1
                else:
                    break
            if is_prime(n) and n not in divided:
                n = 1
                cnt += 1
                break

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


main()
# Original solution
#23ぐらいまでで良さそう。
z = [2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23]

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

sosuu = primes(10001000)
count = [0] * len(sosuu)
convert = [0] * 56

N = int(eval(input()))
ans = 0

flag = True
while (flag):
        flag = False
        for i in range(len(sosuu)):
                if N % sosuu[i] == 0:
                        N = N // sosuu[i]
                        count[i] += 1
                        flag = True

tmp = 0
for i in range(1, 11):
        tmp += i
        convert[tmp] = i
for i in range(1, len(convert)):
        if convert[i] == 0:
                convert[i] = convert[i - 1]


for i in count:
        ans += convert[i]

if N > sosuu[-1] and ans == 0:
        ans = 1
print(ans)





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


hash = {}
end = int(N ** (1/2))
for i in range(2, end + 1):
    while N % i == 0:
        if i in hash:
            hash[i] += 1
        else:
            hash[i] = 1
        N = N // i
if N != 1:
        if N in hash:
            hash[N] += 1
        else:
            hash[N] = 1

if len(list(hash.keys())) == 0 and N != 1:
    print((1))
    exit()


count = 0
trans = [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]

res = 0
for i in list(hash.values()):
    for j in range(len(trans)):
        if i > trans[j]:
            continue
        elif i == trans[j]:
            res += (j + 1)
            break
        else:
            res += j
            break



print(res)
# Original solution
from collections import Counter

def get_prime_factors(x):
    out = []
    if x < 1:
        return out
    while not x%2:
        out.append(2)
        x //= 2
    i = 3
    while i*i <= x:
        if not x%i:
            out.append(i)
            x //= i
        else:
            i += 2
    if x != 1:
        out.append(x)
    return out


def main():
    n = int(eval(input()))
    primes = Counter(get_prime_factors(n))
    ans = 0
    for k, v in list(primes.items()):
        num = 1
        while v >= num:
            v -= num
            num += 1
            ans += 1
    print(ans)
    


if __name__ == "__main__":
    main()

# Optimized solution
from collections import Counter

def get_prime_factors(x):
    out = []
    if x < 1:
        return out
    while not x%2:
        out.append(2)
        x //= 2
    i = 3
    while i*i <= x:
        if not x%i:
            out.append(i)
            x //= i
        else:
            i += 2
    if x != 1:
        out.append(x)
    return out

def main():
    n = int(eval(input()))
    primes = Counter(get_prime_factors(n))
    ans = 0
    for prime, num in list(primes.items()):
        i = 1
        while num >= i:
            ans += 1
            num -= i
            i += 1
    print(ans)
    

if __name__ == "__main__":
    main()
# Original solution
N = int(eval(input()))
n, p, score = N, 2, 0
while p ** 2 <= N:
  e = 1
  while n % (p ** e) == 0:
    n //= (p ** e)
    score += 1
    e += 1
  else:
    while n % p == 0:
      n //= p
    p += 1
else:
  if n != 1:
    score += 1
print(score)

# Optimized solution
N = int(eval(input()))
n, p, score = N, 2, 0
while p ** 2 <= N:
  e = 1
  while n % (p ** e) == 0:
    n //= (p ** e)
    score += 1
    e += 1
  else:
    while n % p == 0:
      n //= p
    p = p + 1 if p == 2 else p + 2
else:
  if n != 1:
    score += 1
print(score)
# Original solution
def prime(n):
    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 = int(eval(input()))
a = prime(N)
a.sort()
import copy
b = copy.copy(a)
b = list(set(b))
b.sort()
m = 0
def cnt(c_, used, ans,now):
    m = ans
    for i in range(len(c_)):
        for j in range(1,a.count(b[i])+1-c_[i]):
            if now*b[i]**j > N:
                break
            if used.count(b[i]**j) != 0:
                continue
            c = copy.copy(c_)
            c[i] += j
            m = max(m, cnt(c, used+[b[i]**j], ans+1, now*b[i]**j))
    return m

m = cnt([0]*len(b), [], 0, 1)
print(m)

# Optimized solution
def prime(n):
    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 = int(eval(input()))
a = prime(N)
a.sort()
import copy
b = copy.copy(a)
b = list(set(b))
b.sort()

ret = 0
for i in b:
    cnt = 0
    idx=0
    while True:
        idx += 1
        cnt = cnt + idx
        if a.count(i) >= cnt:
            ret += 1
        else:
            break

print(ret)
# Original solution
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N=int(eval(input()))
#N=10**18
if N==1:
    print((0))
    exit()

i=2
#N=10**12
def sosuu(x):
    sosuulst=[]
    i=2
    while i<int(x**.5+1):
        for s in sosuulst:
            if i%s==0:
                break
        else:
            sosuulst.append(i)
        i+=1
    for s in sosuulst:
        if x%s==0:
            while x%s==0:
                x//=s
            if x==1:
                return(1)
            else:
                return(0)
    return(1)


c=0
lst=[]
lst2=[]
for i in range(2,int(N**.5+1)):
    if N%i==0:
        lst.append(i)
        lst2.append(N//i)
lst2.reverse()
lst+=lst2
lst.append(N)
#print(lst)
for i in lst:

    if N%i==0:

        if sosuu(i):
        #    print(N,i)
            N//=i
            c+=1
print(c)


# Optimized solution
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N=int(eval(input()))
#N=10**18

lst=defaultdict(int)
lst2=[]
lst3=[]
for i in range(2,int(N**.5)+100):
    if N%i==0:
        lst2.append(i)
        lst3.append(N//i)
lst3.reverse()
lst2+=lst3

for i in lst2+[N]:
    while N>1 and N%i==0:
        N//=i
        lst[i]+=1
c=0
#print(lst)
for s in lst:
    l=lst[s]
    i=1
    while l>=i:
        l-=i
        c+=1
        i+=1
print(c)
# Original solution
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N=int(eval(input()))
#N=10**18

lst=defaultdict(int)
lst2=[]
lst3=[]
for i in range(2,int(N**.5)+100):
    if N%i==0:
        lst2.append(i)
        lst3.append(N//i)
lst3.reverse()
lst2+=lst3

for i in lst2+[N]:
    while N>1 and N%i==0:
        N//=i
        lst[i]+=1
c=0
#print(lst)
for s in lst:
    l=lst[s]
    i=1
    while l>=i:
        l-=i
        c+=1
        i+=1
print(c)


# Optimized solution
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N=int(eval(input()))
#N=10**18

lst=defaultdict(int)

for i in list(range(2,int(N**.5)+100)):
    while N>1 and N%i==0:
        N//=i
        lst[i]+=1
c=0
if N!=1:
    lst[N]+=1
#print(lst)
for s in lst:
    l=lst[s]
    i=1
    while l>=i:
        l-=i
        c+=1
        i+=1
print(c)
# Original solution
from collections import deque
n = int(eval(input()))


def factorization(n):
    retval = []
    tmp = n
    for i in range(2, int(-(-n**.5//1))+1):
        if tmp % i == 0:
            cnt = 0
            while tmp % i == 0:
                cnt += 1
                tmp //= i
            retval.append([i, cnt])

    if tmp != 1:
        retval.append([tmp, 1])
        # retval.append(tmp)
    # if not retval:
        # retval.append((n, 1))
    return retval


fact = factorization(n)
used = set()
m = len(fact)
ans = 0
left = []
# # iこずつとっていく
# for j in range(m):
#     fact[j][1] -= 1
#     ans += 1
#     used.add(fact[j][0])
#     left.extend([fact[j][0] for _ in range(fact[j][1])])

# print(left, used, ans)


for i in range(1, 1000):
    # iこずつとっていく
    for j in range(m):
        if i <= fact[j][1]:
            fact[j][1] -= i
            ans += 1
            used.add(fact[j][0]**i)
    # 組み合わせて、iこ取れるか確かめる
print(ans)

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


def factorization(n):
    retval = []
    tmp = n
    for i in range(2, int(-(-n**.5//1))+1):
        if tmp % i == 0:
            cnt = 0
            while tmp % i == 0:
                cnt += 1
                tmp //= i
            retval.append([i, cnt])
    if tmp != 1:
        retval.append([tmp, 1])
    return retval


fact = factorization(n)
m = len(fact)
ans = 0
for i in range(1, 1000):
    for j in range(m):
        if i <= fact[j][1]:
            fact[j][1] -= i
            ans += 1
print(ans)
# Original solution
# coding: utf-8
# Your code here!
import bisect

line=[i*(i+1)//2 for i in range(10**7+1)]

N=int(eval(input()))

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

do=[0 for i in range(10**6+1)]

for i in range(2,int(N**0.5)+1):
    while N%i==0:
        N/=i
        do[i]+=1

ans=0
judge=True

for _,item in enumerate(do):
    index=(bisect.bisect_right(line,item))-1
    ans+=index
    if index!=0:
        judge=False

print((ans+1 if judge else ans))




# Optimized solution
# coding: utf-8
# Your code here!
import bisect

line=[i*(i+1)//2 for i in range(10**6+1)]

N=int(eval(input()))


do=[0 for i in range(10**6+1)]

for i in range(2,int(N**0.5)+1):
    while N%i==0:
        N/=i
        do[i]+=1

ans=0 if N==1 else 1

for _,item in enumerate(do):
    index=(bisect.bisect_right(line,item))-1
    ans+=index

print(ans)
# Original solution
# -*- coding: utf-8 -*-
import collections
# factrize
def factorize(target_number):
    factor = 2
    factor_list = []
    while factor * factor <= target_number:
        while target_number % factor == 0:
            target_number //= factor
            factor_list.append(factor)
        factor += 1
    if target_number > 1:
        factor_list.append(target_number)
    return factor_list

N = int(eval(input()))

fact_list = factorize(N)

fact_counter_dict = collections.Counter(fact_list)
ans = 0
for fact, freq in list(fact_counter_dict.items()):
    freq_copy = freq
    for i in range(1, freq + 1):
        freq_copy -= i
        if freq_copy < 0:
            break
        ans += 1
print(ans)

# Optimized solution
# -*- coding: utf-8 -*-
import collections
# factrize
def factorize(target_number):
    factor_list = []
    while target_number % 2 == 0:
        factor_list.append(2)
        target_number //= 2
    factor = 3
    while factor * factor <= target_number:
        while target_number % factor == 0:
            target_number //= factor
            factor_list.append(factor)
        factor += 2
    if target_number > 1:
        factor_list.append(target_number)
    return factor_list

N = int(eval(input()))

fact_list = factorize(N)

fact_counter_dict = collections.Counter(fact_list)
ans = 0
for fact, freq in list(fact_counter_dict.items()):
    freq_copy = freq
    for i in range(1, freq + 1):
        freq_copy -= i
        if freq_copy < 0:
            break
        ans += 1
print(ans)
# Original solution
import math
import sys
from collections import Counter

N = int(eval(input()))
Ns = N
Nso = []
i = 0
if N == 1:
    print((0))
    sys.exit()

Nruto = math.sqrt(N)
Nruto = math.floor(Nruto)


# 素因数分解していきますpart2
for i in range(2, Nruto+1):
    while N % i == 0:
        N = N//i
        Nso.append(i)
    if N == 1:
        break
    Nruto = math.sqrt(N)
    Nruto = math.floor(Nruto)

Nso.append(N)
if 1 in Nso:
    Nso.remove(1)

# Nso^xの形にカウントしていきます
Nso.sort()
Nso = Counter(Nso)


# 設問の操作をしていきます
x = 0
count = 0
xcount = 0
while Ns > 1 and x <= len(Nso):
    for x in list(Nso.keys()):
        for y in range(1, Nso[x]+1, +1):
            if Ns % (x**y) == 0:
                count = count+1
                Ns = Ns/(x**y)
                xcount = xcount+y
            else:
                break

print(count)


# Optimized solution
from collections import Counter
import sys
import math
N = int(eval(input()))
M = N
Nso = []
Nruto = math.sqrt(N)
Nruto = math.ceil(Nruto)
for i in range(2, Nruto+1):
    while N % i == 0:
        N = N//i
        Nso.append(i)
    if N == 1:
        break
    Nruto = math.sqrt(N)
    Nruto = math.floor(Nruto)

Nso.append(N)
if 1 in Nso:
    Nso.remove(1)

if len(Nso) == 0:
    if M == 1:
        print((0))
    else:
        print((1))
    sys.exit()

ans = 0
Nso = Counter(Nso)

for i in list(Nso.values()):
    x = math.sqrt(2*i)
    x = math.floor(x)
    for j in range(x, 0, -1):
        if j*j+j <= 2*i:
            ans += j
            break
print(ans)
# Original solution
#-------------------------------------------------------------------
import sys
def p(*_a):
  _s=" ".join(map(str,_a))
  #print(_s)
  sys.stderr.write(_s+"\n")
#-------------------------------------------------------------------
import math

def factorize(n):
  ret, a = [], n
  for i in range(2, int(n**0.5)+1):
    if a%i>0: continue
    c=0
    while a%i==0:
      a//=i
      c+=1
    else:
      ret.append((i,c))
  if a!=1: ret.append((a,1))
  return ret

#nの素数判定
def is_prime(n):
	if n == 1:
		return False
	for i in range(2,int(n**0.5)+1):
		if n % i == 0: return False
	return True


n = int(eval(input()))
N = factorize(n)
#p(N)

i = 2
ans=0
while n >= i:
  if is_prime(n):
    n /= n
    ans += 1
    #p("ans=",ans)
  elif n % i ==0:
    for k,_ in N:
      a = math.log(i, k)
      #p("n,i,k,a,int(a)=",n,i,k,int(a),a)
      if int(a)==a:
        n /= i
        ans += 1
        #p("ans=",ans)

  i += 1

print(ans)


# Optimized solution
#-------------------------------------------------------------------
import sys
def _p(*_a):
  _s=" ".join(map(str,_a))
  #print(_s)
  sys.stderr.write(_s+"\n")
#-------------------------------------------------------------------
import math

def factorize(n):
  ret, a = [], n
  for i in range(2, int(n**0.5)+1):
    if a%i>0: continue
    c=0
    while a%i==0:
      a//=i
      c+=1
    else:
      ret.append((i,c))
  if a!=1: ret.append((a,1))
  return ret


n = int(eval(input()))
N = factorize(n)

ans=0
for p,i in N:
  for j in range(i):
    a = pow(p,j+1)
    if n % a == 0:
      n /= a
      ans += 1

print(ans)