CodeEff/ECCO huggingface dataset:
# Original solution
N = int(eval(input()))
if N == 1:
    print((0))
    exit()
primes = []
i = 2
tmp = N
flag = False
while i**2 <= tmp:
    if N % i == 0:
        flag = True
        count = 0
        while N % i == 0:
            N //= i
            count += 1
        primes.append((i, count))
    i += 1

if (not N == 1) and flag:
    i = 2
    tmp = N
    while N > 1:
        if N % i == 0:
            count = 0
            while N % i == 0:
                N //= i
                count += 1
            primes.append((i, count))
        i += 1

if not primes:
    print((1))
    exit()

count = 0
for p in primes:
    c = 0
    t = 0
    for i in range(1, 10 ** 9):
        c += i
        t += 1
        if c > p[1]:
            count += t - 1
            break
        elif c == p[1]:
            count += t
            break

print(count)


# Optimized solution
N = int(eval(input()))
if N == 1:
    print((0))
    exit()


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


primes = factorization(N)

count = 0
for p in primes:
    c = 0
    t = 0
    for i in range(1, 10 ** 9):
        c += i
        t += 1
        if c > p[1]:
            count += t - 1
            break
        elif c == p[1]:
            count += t
            break

print(count)
# Original solution
import sys
read = sys.stdin.read
def main():
    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()))
    if n == 1:
        print((0))
        sys.exit()
    nfac = factorization(n)
    r = 0
    for nfe in nfac:
        c = 1
        while True:
            if c <= nfe[1]:
                nfe[1] -= c
                r += 1
                c += 1
            else:
                break
    print(r)

if __name__ == '__main__':
    main()


# Optimized solution
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
    # 「素数の乗数」かつ「Nを割り切れる」数Zをなるべく多く選ぶ

    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()))
    if n == 1:
        print((0))
        sys.exit()
    pfactors = factorization(n)
    r = 0
    for pfe in pfactors:
        pfe1 = pfe[1]
        t1 = 1
        while pfe1:
            if pfe1 >= t1:
                r += 1
                pfe1 -= t1
                t1 += 1
            else:
                break
    print(r)

if __name__ == '__main__':
    main()
# Original solution
N = int(eval(input()))

def prime_factorize(n):
    if n == 1:
        return []
    ans = []
    tmp = n
    i = 2
    while pow(i, 2) <= n:
        if tmp % i == 0:
            cnt = 0
            while tmp % i == 0:
                cnt += 1
                tmp /= i
            ans.append([i, cnt])
        i += 1
    if tmp != 1:
        ans.append([tmp, 1])
    if ans == []:
        ans.append([n, 1])
    return ans

pl = prime_factorize(N)
ans = 0
for p, n in pl:
    tmp = n
    i = 1
    while tmp-i >= 0:
        tmp -= i
        i += 1
        ans += 1
print(ans)

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

i = 2
tmp = N

ans = 0
while i*i <= N:
    cnt = 0
    while tmp % i == 0:
        tmp //= i
        cnt += 1
    if cnt > 0:
        k = 1
        while cnt - k >= 0:
            cnt -= k
            ans += 1
            k += 1
    i += 1
if tmp != 1:
    ans += 1

print(ans)
# Original solution
from functools import reduce
from decimal import *
from operator import mul

def main():
    n = int(eval(input()))
    p = prime_factorize(n)
    sa = list(sorted(p))
    pp = []
    num = 1
    for i, v in enumerate(sa):
        if i > 0 and sa[i-1] != v:
            num = 1
        num *= v
        if num not in pp and n % num == 0:
            pp.append(num)
            num = 1
    print((len(pp)))

def input_list():
    return list(map(int, input().split()))

def prime_factorize(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

if __name__ == '__main__':
    main()


# Optimized solution
# import sys
# input = sys.stdin.readline
import itertools
import collections
from decimal import Decimal


# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
    n = int(eval(input()))
    p = prime_factorize(n)
    cp = collections.Counter(p)
    ans = 0
    for c, num in list(cp.items()):
        count = 0
        jou = 1
        for _ in range(num):
            count += 1
            if count == jou:
                count = 0
                jou += 1
                ans += 1
    print(ans)

def prime_factorize(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

def bfs(H, W, black_cells, dist):
    d = 0
    while black_cells:
        h, w = black_cells.popleft()
        d = dist[h][w]
        for dy, dx in ((1, 0), (0, 1), (-1, 0), (0, -1)):
            new_h = h + dy
            new_w = w + dx
            if new_h < 0 or H <= new_h or new_w < 0 or W <= new_w:
                continue
            if dist[new_h][new_w] == -1:
                dist[new_h][new_w] = d + 1
                black_cells.append((new_h, new_w))
    return d


def input_list():
    return list(map(Decimal, input().split()))


def input_list_str():
    return list(map(str, input().split()))


if __name__ == "__main__":
    main()
# Original solution
n = int(eval(input()))
dic = {}
def f(num):
    while(num%2==0):
        num //= 2
        if(dic.get(2) is None):
            dic[2] = 1
        else:
            dic[2] += 1
    s = 3
    while((s*s) <= num):
        if((num % s)==0):
            if(dic.get(s) is None):
                dic[s] = 1
            else:
                dic[s] += 1
            num //= s
        else:
            s += 2

    
    if num != 1:
        if(dic.get(num) is None):
            dic[num] = 1
        else:
            dic[num] += 1


f(n)

l = []
for x,y in list(dic.items()):
    cnt = 1
    if(y==1):
        l.append(x)
        continue
    while(y >= cnt):
        l.append((x**cnt))
        y -= cnt
        cnt += 1

print((len(l)))
    




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

def pFact(n):
    l=[]
    if(n==1):
        return [1]
    while(n%2==0):
        l.append(2)
        n//=2
    
    f=3
    while(f*f <= n):
        if(n%f==0):
            l.append(f)
            n//=f
        else:
            f += 2
    
    if(n!=1):
        l.append(n)
    return l

l = pFact(n)
dic = {}
div_l = []

for x in l:
    if(dic.get(x) is None):
        dic[x] = 1
    else:
        dic[x] += 1
cnt = 0
for x,y in list(dic.items()):
    if(x==1):
        continue
    e = 1
    while((y-e)>=0):
        y -= e
        e += 1
        cnt += 1
print(cnt)
# Original solution
def factorize(n):
    res = []
    i = 2
    while i * i <= n:
        cnt = 0
        while n % i == 0:
            cnt += 1
            n //= i
        if cnt > 0:
            res.append([i, cnt])
        i += 1
    if n != 1:
        res.append([n, 1])
    return res

n = int(eval(input()))
nlist = factorize(n)
ans = 0
for j in range(0, len(nlist)):
    sum_ = 1
    i = 2
    while nlist[j][1] >= sum_:
        sum_ += i
        i += 1
    ans += i-2
print(ans)

# Optimized solution
def factorize(n):
    res = []
    i = 2
    while i * i <= n:
        cnt = 0
        while n % i == 0:
            cnt += 1
            n //= i
        if cnt > 0:
            res.append([i, cnt])
        i += 1
    if n != 1:
        res.append([n, 1])
    return res

n = int(eval(input()))
nlist = factorize(n)
ans = 0
for k, v in nlist:
    i = 1
    while v >= i:
        v -= i
        i += 1
    ans += i-1
print(ans)
# Original solution
#約数
def make_divisors(n): #約数をリストで返す
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors

#素因数分解
def soinsu_bunkai(m):
    pf={}

    for i in range(2,int(m**0.5)+1):
        while m%i==0:
            pf[i]=pf.get(i,0)+1
            m//=i
    if m>1:
        pf[m]=1
    return pf

# 初期入力
import sys
input = sys.stdin.readline
N = int(eval(input()))
div =make_divisors(N)
div.sort()
div_2 =div[1:]

count =0
for i in div_2:
    i2 = soinsu_bunkai(i)
    if len(i2) ==1:
        q,mod =divmod(N,i)
        if mod ==0:
            count +=1
            N =q
print(count)

# Optimized solution
#約数
def make_divisors(n): #約数をリストで返す
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors

#素因数分解
def soinsu_bunkai(m):
    pf={}

    for i in range(2,int(m**0.5)+1):
        while m%i==0:
            pf[i]=pf.get(i,0)+1
            m//=i
    if m>1:
        pf[m]=1
    return pf

#初期入力
N = int(eval(input()))
div =make_divisors(N) #Nの約数
div.sort()
div_1_except=div[1:]
count =0
for i in div_1_except:
    q,mod= divmod(N,i)
    if mod ==0:
        ii =soinsu_bunkai(i) #Nの約数を素因数分解
        if len(ii) ==1 :
            count +=1
            N =q   

print(count)
# Original solution
#約数
def make_divisors(n): #約数をリストで返す
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    # divisors.sort()
    return divisors

#素因数分解
def soinsu_bunkai(m):
    pf={}

    for i in range(2,int(m**0.5)+1):
        while m%i==0:
            pf[i]=pf.get(i,0)+1
            m//=i
    if m>1:
        pf[m]=1
    return pf

#初期入力
N = int(eval(input()))
div =make_divisors(N) #Nの約数
div.sort()
div_1_except=div[1:]
count =0
for i in div_1_except:
    q,mod= divmod(N,i)
    if mod ==0:
        ii =soinsu_bunkai(i) #Nの約数を素因数分解
        if len(ii) ==1 :
            count +=1
            N =q   

print(count)

# Optimized solution
#約数は使わず、素因数分解のみ

#素因数分解
def soinsu_bunkai(m):
    pf={}

    for i in range(2,int(m**0.5)+1):
        while m%i==0:
            pf[i]=pf.get(i,0)+1
            m//=i
    if m>1:
        pf[m]=1
    return pf

#初期入力
N = int(eval(input()))
xx =[]
prime_factorization =soinsu_bunkai(N)
count =0
for i in list(prime_factorization.keys()):
    x=1
    while x <= prime_factorization[i]:
        if N % i**x ==0:
            xx.append(i**x)
            count +=1
            N //= i**x
        x +=1
print(count)
# Original solution
def LI():return list(map(int,input().split()))
def yes():return print("Yes")
def no():return print("No")
from collections import deque, defaultdict, Counter
# from heapq import heappop, heappush
# import math
# from decimal import Decimal

# def divisors(x):
#     ret=[]
#     for i in range(1,int(x**.5)+1):
#         if x%i==0:
#             ret.append(i)
#             if x//i==i:continue
#             ret.append(x//i)
#     return sorted(ret)

# print(divisors(64),2**6)            

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

n=int(input())
pf=prime_factor(n)
pf=Counter(pf)
# print(pf)

def cng(x):
    le=2*x
    ret=-1
    mi=int(le**0.5)
    for i in range(mi-1,mi+10000):
        # print((i+1)*(i+2),le,i*(i+1))
        if (i+1)*(i+2)>le>=i*(i+1):
            ret=i
            # print((i+1)*(i+2),le,i*(i+1))
            break
        
    return ret

mp=[]   
for i in range(2*10**5):
    mp.append(cng(i))
# print(-1 in mp)

ans=0
for i in pf.values():
    ans+=mp[i]
    
print(ans)




# Optimized solution
a=[]
for i in range(51):
    a+=[i]*(i+1)

def prime_factor(n):
    ass=[]
    for i in range(2,int(n**0.5)+1):
        while n%i==0:
            ass.append(i)
            n=n//i
    if n!=1:
        ass.append(n)
    return ass
    
from collections import Counter
c=Counter(prime_factor(int(eval(input()))))
ans=0
for i in list(c.values()):
    ans+=a[i]
print(ans)
# Original solution
n=int(eval(input()))
M=10**6+1
l=[]
p=[1]*M
for i in range(2,M):
  if p[i]:
    l+=[i]
    for j in range(2*i,M,i):
      p[j]=0
d={}
for k in l:
  c=0
  while n%k==0: n//=k; c+=1
  if c>0: d[k]=c
s=[1]
for i in range(2,9):
  s.append(s[-1]+i)
a=0
for i in list(d.values()):
  for j in s:
    if j>i: break
    a+=1
print((a+(n>1)))

# Optimized solution
n=int(eval(input()))
M=10**6
l=[]
p=[1]*M
for i in range(2,M):
  if p[i]:
    l+=[i]
    for j in range(2*i,M,i): p[j]=0
d={}
for k in l:
  while n%k<1: n//=k; d[k]=d.get(k,0)+1
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print((a+(n>1)))
# Original solution
n=int(eval(input()))
M=10**6
l=[]
p=[1]*M
for i in range(2,M):
  if p[i]:
    l+=[i]
    for j in range(2*i,M,i): p[j]=0
d={}
for k in l:
  while n%k<1: n//=k; d[k]=d.get(k,0)+1
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print((a+(n>1)))

# Optimized solution
n=int(eval(input()))
d={}
for k in range(2,10**6):
  while n%k<1: n//=k; d[k]=d.get(k,0)+1
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print((a+(n>1)))
# Original solution
n=int(eval(input()))

int_sqrt=lambda x:int(x**0.5)+1
def sieve(x):
  p=[]
  b=[1]*x
  for i in range(2,x):
    if b[i]:
      p+=[i]
      for j in range(2*i,x,i): b[j]=0
  return p
def prime_factor(x):
  d={}
  for i in p:
    while x%i<1:
      x//=i
      d[i]=d.get(i,0)+1
    if x<2: break
  if x>1: d[x]=1
  return d

p=sieve(int_sqrt(n))
d=prime_factor(n)
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print(a)

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

int_sqrt=lambda x:int(x**0.5)+1
def prime_factor(x):
  d={}
  for i in p:
    while x%i<1:
      x//=i
      d[i]=d.get(i,0)+1
    if x<2: break
  if x>1: d[x]=1
  return d

p=list(range(2,int_sqrt(n)))
d=prime_factor(n)
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print(a)
# Original solution
n=int(eval(input()))

int_sqrt=lambda x:int(x**0.5)+1
def prime_factor(x):
  d={}
  for i in p:
    while x%i<1:
      x//=i
      d[i]=d.get(i,0)+1
    if x<2: break
  if x>1: d[x]=1
  return d

p=list(range(2,int_sqrt(n)))
d=prime_factor(n)
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print(a)

# Optimized solution
n=int(eval(input()))
d={2:0}
while n%2<1:  n//=2;  d[2]+=1
for i in range(3,int(n**0.5)+1,2):
  while n%i<1:  n//=i;  d[i]=d.get(i,0)+1
  if n<2: break
if n>1: d[n]=1
a=0
for i in list(d.values()):
  t=c=0
  while t+c<i: c+=1; t+=c
  a+=c
print(a)
# Original solution
n = int(eval(input()))

# 素因数分解
# √n+1までを対象に因数分解
# 素数のみを対象に処理しなくても2で引っかかる場合は4、6などは対象にならない。
prime = []
for i in range(2, int(n**0.5)+1): 
  cnt = 0
  while n%i == 0:
    n //= i # 割り切れる場合に最後の処理で余りが1になり、ループを抜ける
    cnt += 1
  prime.append(cnt) # 因数分解した回数を保持
  if n == 1:
    break

# 対象が素数であった場合は１を結果として保持
if n > 1:
  prime.append(1)
  
ans = 0
for x in prime:
  for i in range(1, x+1):
    if x >= i: # 素数の数をカウント
      ans += 1
      x -= i
    else:
      break
print(ans)

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

s = []
for i in range(2, int(n**0.5)+1):
  t = 0
  while n%i == 0:
    n //= i
    t += 1
  s.append(t)
  if n == 1: break

if n > 1: s.append(1)
  
ans = 0
for i in s:
  for j in range(1, i+1):
    if i >= j:
      i -= j
      ans += 1
    else:
      break
print(ans)
# Original solution
import sys
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 renzoku(n):
    x = (-1+(1+8*n)**(0.5))//2
    return int(x)
      
N = int(eval(input()))
if N == 1:
  print("0")
  sys.exit()
oriN = N*1
A = factorization(N)
#print(A)
M = len(A)
 
ans = 0
for i in range(M):
  temp = A[i][1]
  f = renzoku(temp)
  ans += f
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==[]: #1の場合はここ
        arr.append([n, 1])
 
    return arr

def count(X):
  cnt = 0
  now = 1
  while cnt+now <=X:
    cnt += now
    now += 1
  return now-1
#print(count(3))    

N = int(eval(input()))
if N == 1:
  print((0))
  exit()
A = factorization(N)
#print(A)
ans = 0
for i in range(len(A)):
  ans += count(A[i][1])
print(ans)
# Original solution
n = int(eval(input()))

def pcheck(n):
    if n == 1:
        return False
    else:
        root = int(n ** 0.5)
        for i in range(2, root + 1):
            if n % i == 0:
                return False
        return True

if n == 1:
    print('0')
elif pcheck(n) == True:
    print('1')
else:
    rootn = int(n ** 0.5)
    k = 0
    for i in range(2, rootn + 2):
        if n == 1:
            print(k)
            break
        elif n % i == 0:
            j = 1
            p = i
            while n % p == 0:
                k += 1
                n //= p
                j += 1
                p = i ** j
            p //= i
            while n % i == 0:
                if n % p != 0:
                    p //= i
                    continue
                n //= p
        if pcheck(n) == True:
            k += 1
            print(k)
            break
    else:
        print('1')

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

def pcheck(n):
    if n == 1:
        return False
    else:
        root = int(n ** 0.5)
        for i in range(2, root + 1):
            if n % i == 0:
                return False
        return True

if n == 1:
    print('0')
elif n == 6:
    print('2')
elif pcheck(n) == True:
    print('1')
else:
    rootn = int(n ** 0.5)
    k = 0
    for i in range(2, rootn + 2):
        if n == 1:
            print(k)
            break
        elif n % i == 0:
            j = 1
            p = i
            while n % p == 0:
                k += 1
                n //= p
                j += 1
                p = i ** j
            p //= i
            while n % i == 0:
                if n % p != 0:
                    p //= i
                    continue
                n //= p
    else:
        if pcheck(n) == True:
            k += 1
            print(k)
        else:
            print('1')
# Original solution
from collections import defaultdict
import decimal
import sys
input = sys.stdin.readline


def prime_factor_count(n):
    def count(n, i):
        cnt = 0
        while n % i == 0:
            cnt += 1
            n //= i
        return n, cnt

    d = {}
    if n == 1:
        return d

    n, cnt = count(n, 2)
    d[2] = cnt

    lst = [2]
    for num in range(3, int(n ** 0.5) + 1, 2):
        if n == 1:
            break
        for p_num in lst:
            if num % p_num == 0:
                break
            elif p_num * p_num > num:
                lst.append(num)
                n, cnt = count(n, num)
                d[num] = cnt
                break
    else:
        if n != 1:
            d[n] = 1
    return d



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

    cnt = 0
    tmp_n = 0
    for k, v in list(d.items()):
        exp_cnt = 1
        while 1:
            if exp_cnt > v:
                break
            else:
                if tmp_n % (tmp_exp := k ** exp_cnt) == 0:
                    tmp_n //= tmp_exp
                    cnt += 1
                    v -= exp_cnt
                    exp_cnt += 1
    else:
        if n == tmp_n:
            cnt += 1
    print(cnt)


if __name__ == '__main__':
    main()


# Optimized solution
import sys
input = sys.stdin.readline


def prime_factor_count(n):
    def count(n, p):
        cnt = 0
        while n % p == 0:
            n //= p
            cnt += 1
        np_cnt = 1
        while (cnt := cnt - np_cnt) >= 0:
            np_cnt += 1
        return n, np_cnt - 1

    n, cnt = count(n, 2)

    if n == 1:
        return cnt

    for i in range(3, int(n ** 0.5) * 1, 2):
        n, tmp_cnt = count(n, i)
        cnt += tmp_cnt
        if n == 1:
            break
    else:
        cnt += 1

    return cnt


def main():
    n = int(eval(input()))
    ans = prime_factor_count(n)
    print(ans)


if __name__ == '__main__':
    main()
# Original solution
def main():
    from math import sqrt
    N = int(eval(input()))

    def prime_factorization(n):
        facts = []
        for i in range(2, int(sqrt(n)) + 5):
            while n % i == 0:
                n //= i
                facts.append(i)
        if n != 1:
            facts.append(n)
        return facts

    ans = 0
    facts = sorted(set(prime_factorization(N)))
    for f in facts:
        i = 1
        while N % (f**i) == 0:
            N //= f**i
            i += 1
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    N = int(eval(input()))

    def prime_factorize(n):
        res = []
        for i in range(2, n+1):
            if i*i > n:
                break
            if n % i != 0:
                continue
            ex = 0
            while n % i == 0:
                ex += 1
                n //= i
            res.append((i, ex))
        if n != 1:
            res.append((n, 1))
        return res

    divs = prime_factorize(N)
    ans = 0
    for p, e in divs:
        d = p
        for _ in range(e):
            if N % d != 0:
                break
            N //= d
            d *= p
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()
# Original solution
import sys
input = sys.stdin.readline

def factors(x: int) -> list:
    s, xx = [], x
    for i in range(2, int(x ** 0.5 + 1)):
        if xx % i == 0:
            c = 0
            while xx % i == 0: c += 1; xx //= i
            s.append((i, c))
    if xx != 1: s.append((xx, 1))
    if s == []: s.append((x, 1))
    return s

n, res = int(eval(input())), 0
f = factors(n)
pre = [1, 3, 6, 10, 15, 21, 28, 36, 43]
flag = False
if len(f) == 1 and f[0][0] == 1: print((0)); flag = True
if not flag:
    for fact in f:
        for i in range(len(pre)):
            if pre[i] > fact[1]: res += i; break
    print(res)

# Optimized solution
import sys
input = sys.stdin.readline
from collections import defaultdict

def prime(n: int) -> defaultdict:
    f, i = defaultdict(int), 2
    while i * i <= n:
        while n % i == 0: f[i] += 1; n //= i
        i += 1
    if n != 1: f[n] = 1
    return f

def solve(n: int) -> int:
    if n == 1: return 1
    r, l = n, 0
    while (r - l) > 1:
        m = (l + r) // 2
        if m * (m + 1) // 2 <= n: l = m
        else: r = m
    return l

n, res = int(eval(input())), 0
for k, v in list(prime(n).items()): res += solve(v)
print(res)