// Slower C++ solution:
#include<stdio.h>

#include<stdlib.h>

#include<time.h>

typedef long long LL;

const int e[40]={0,1,1,2,2,2,3,3,3,3,4,4,4,4,4,5,5,5,5,5,

               5,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,8,8,8,8};

const LL UnUseMethod=11e11;

LL count[2]={0};

LL IN(void)

{

  LL x=0;short f=0,c=getchar();while(c<48||c>57){f^=c==45,c=getchar();}

  while(c>47&&c<58){x=x*10+c-48,c=getchar();}return f?-x:x;

}

LL GCD(LL a,LL b){return !b?a:GCD(b,a%b);}

LL Mult(LL x,LL y,LL mod)

{LL temp=x*y-(LL)((long double)x/mod*y+1e-8)*mod;return temp<0?temp+mod:temp;}

LL BinaryModularPower(LL base,LL pow,LL mod)

{

  LL x=1;

  while(pow){if(pow&1){x=Mult(x,base,mod);}base=Mult(base,base,mod);pow>>=1;}

  return x;

}

LL f(LL x,LL mod,LL c){return (Mult(x,x,mod)+c)%x+1;}

void Exp(LL x,LL y){count[1]=0;while(!(x%y)){count[1]++;x/=y;}count[0]=x;return;}

int MillerRabin(const LL a)

{

  if(a==2)return 1;

  if(a%2==0||a==1)return 0;

  static int pr[7]={2,325,9375,28178,450775,9780504,1795265022};

  LL u=a-1,t=0,p=1;

  while(!(u&1)){u>>=1;t++;}

  for(int i=0;i<7;++i)

  {

    p=pr[i]%a;

    if(!p)return 1;

    LL x=BinaryModularPower(p,u,a);

    if(x==1)continue;

    for(int j=0;x!=a-1&&j<t;++j)

    {

      x=Mult(x,x,a);

      if(x==1)return 0;

    }

    if(x==a-1)continue;

    return 0;

  }

  return 1;

}

LL PollardRho(LL n,LL a)

{

  srand((unsigned int)time(NULL));

  LL x=rand()%n,y=x,gcd=1,k=0,i=1;

  while(gcd==1)

  {

    k++;

    x=Mult(x,x,n)+a;if(x>=n)x-=n;

    gcd=GCD(x>y?x-y:y-x,n);

    if(k==i){y=x;i<<=1;}

  }

  if(gcd==n)return PollardRho(n,a+1);

  return gcd;

}

int main(void)

{

  LL a=0,p=1,q=-1,N=IN();

  if(N<=1)return puts("0"),0;

  Exp(N,2);a=e[count[1]];N=count[0];

  Exp(N,3);a+=e[count[1]];N=count[0];

  while(q*q<=UnUseMethod)

  {

    p+=6,q+=6;

    Exp(N,p);a+=e[count[1]];N=count[0];

    Exp(N,q);a+=e[count[1]];N=count[0];

  }

  if(N<=UnUseMethod){if(N>1){a++;}return printf("%lld\n",a),0;}

  if(MillerRabin(N)){a++;return printf("%lld\n",a),0;}

  while(N>=UnUseMethod)

  {

    p=PollardRho(N,0);

    while(!MillerRabin(p))p=PollardRho(p,p);

    Exp(N,p);a+=e[count[1]];N=count[0];

  }

  if(MillerRabin(N)){a++;}return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 6.044182899780783x):
#include<stdio.h>

#include<stdlib.h>

#include<math.h>

#include<time.h>

typedef long long LL;

const int e[40]={0,1,1,2,2,2,3,3,3,3,4,4,4,4,4,5,5,5,5,5,

                 5,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,8,8,8,8};

const int mp[16]={1,3,5,7,11,15,21,33,35,55,77,105,165,231,385,1155};

const int results[16]={1,0,0,0,0,3,3,3,5,5,7,3,3,3,5,3};

const LL UnUseMethod=4759123141;

const unsigned long ULONG=18446744073709551615U;

int sz=0;LL count[2]={0},Box[10]={0};

LL IN(void)

{

  LL x=0;short f=0,c=getchar();while(c<48||c>57){f^=c==45,c=getchar();}

  while(c>47&&c<58){x=x*10+c-48,c=getchar();}return f?-x:x;

}

inline LL GCD(LL a,const LL b){return !b?a:GCD(b,a%b);}

inline LL Mult(const LL x,const LL y,const LL mod)

{LL z=x*y-(LL)((long double)x/mod*y+1e-8)*mod;return z<0?z+mod:z;}

inline LL BinaryModularPower(LL base,LL pow,const LL mod)

{

  LL x=1;

  while(pow){if(pow&1){x=Mult(x,base,mod);}base=Mult(base,base,mod);pow>>=1;}

  return x;

}

void Exp(LL x,const LL y)

{count[1]=0;if(!y){return;}while(!(x%y)){count[1]++;x/=y;}count[0]=x;return;}

inline LL Pseudo(const LL x){return (LL)((long double)pow(x,0.5));}

inline int PerfectSquare(const LL x){if(x<0)return 0;else{LL y=Pseudo(x);return x==y*y;}}

inline int PerfectCube(const LL x){LL z=(LL)cbrt(x);return x==z*z*z;}

int MillerRabin(const LL a)

{

  /*http://www.olivierlanglois.net/archive/prime_cpp.htm*/

  if(a==2)return 1;

  if((a&1)==0||a<2)return 0;

  if(PerfectSquare(a))return 0;

  if(PerfectCube(a))return 0;

  static const int pr[7]={2,325,9375,28178,450775,9780504,1795265022};

  LL odd=a-1,k=0,p=1,x;

  while(!(odd&1)){odd>>=1;k++;}

  for(int i=0;i<7;++i)

  {

    p=(LL)(pr[i]%a);

    if(!p)return 1;

    x=BinaryModularPower(p,odd,a);

    if(x==1||x==a-1)return 1;

    for(int j=0;j<k;j++)

    {

      x=BinaryModularPower(x,2,a);

      if(x==a-1)return 1;

    }

  }

  return 0;

}

inline LL PollardRho(const LL n,const LL a)

{

  if(MillerRabin(n))return n;

  if(PerfectSquare(n))return Pseudo(n);

  if(PerfectCube(n))return (LL)cbrt(n);

  LL x=rand()%n,y=x;static LL gcd=1,k=0,i=1;

  while(gcd==1)

  {

    k++;

    x=Mult(x,x,n)+a;if(x>=n)x-=n;

    gcd=GCD(x>y?x-y:y-x,n);

    if(k==i){y=x;i<<=1;}

  }

  if(gcd==n)return PollardRho(n,a+1);

  return gcd;

}

signed main(void)

{

  LL a=0,p=1,q=-1,N=IN();

  if(N<=1)return puts("0"),0;

  Exp(N,2);a=e[count[1]];N=count[0];

  Exp(N,3);a+=e[count[1]];N=count[0];

  while(q*q<=UnUseMethod)

  {

    p+=6,q+=6;

    Exp(N,p);a+=e[count[1]];N=count[0];

    Exp(N,q);a+=e[count[1]];N=count[0];

  }

  if(N<=UnUseMethod){if(N>1){a++;}return printf("%lld\n",a),0;}

  if(MillerRabin(N)){a++;return printf("%lld\n",a),0;}

  srand((unsigned int)time(NULL));

  while(N>=UnUseMethod)

  {

    p=PollardRho(N,0);

    while(!MillerRabin(p))p=PollardRho(N,p);

    Exp(N,p);a+=e[count[1]];N=count[0];

  }

  if(MillerRabin(N)){a++;}return printf("%lld\n",a),0;

}