stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
 #include<bits/stdc++.h>

#include<iostream>

#include<algorithm>

#include<cstring>

#include<cstdio>

#include<cmath>

#define ll  long long

#define ull unsigned long long

#define IO ios::sync_with_stdio(false), cin.tie(0)

#define endl '\n'

#define main() int main()

#define ff1(i,n) for(int i=1;i<=n;++i)

#define ff0(i,n) for(int i=0;i<n;++i)

#define pi acos(-1.0)

#define ms(a, x) memset(a, x, sizeof(a))

#define lowbit(x) ((x)&(-(x)))

#define pb push_back

#define binarycount __builtin_popcount(x)

#define tr t[root]

#define lson t[root << 1]

#define rson t[root << 1 | 1]

#define fir first

#define sec second

#define debug(x) cout<<x<<'\n'

#define sa(a) scanf("%d", &a)

#define sab(a, b) scanf("%d%d", &a, &b)

#define pa(a) printf("%d",a)

#define pab(a,b) printf("%d%d",a,b)

#define pii pair<ll,ll>

using namespace std;



#define maxn 1000005

const int inf = 0x3f3f3f3f;

const int mod = 1e9+7;

const double eps = 1e-8;

ll gcd(ll a, ll b) {return b==0?a:gcd(b, a%b);}

ll lcm(ll a, ll b) {return a/gcd(a, b)*b;}

ll powmod(ll a,ll b){

    ll ans = 1, pow = a%mod;

    while(b) { if(b&1) ans = (ans*pow)%mod; pow = (pow*pow)%mod; b >>= 1; }

    return ans%mod;

}

main()

{  

    ll n;

	cin>>n; 

    vector<pair<ll, ll>> v;

    for (ll i=2;i*i<=n;i++){

        if (n%i==0) {

            v.pb(pii(i, 0));

            while (0==n%i) {

                v.back().second++;

                n/=i;

            }

        }

    }

    if (n>1) {

        v.pb(pii(n, 1));

    }

    ll ans=0;

    for (pii &p:v) {

        ll i=sqrt(p.second*2);

        if (i*(i+1)>p.second*2)  i--;

        ans+=i;

    }

 

    cout<<ans<<endl;

}

 

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

#define LL long long

int p[50],m[50],tot;//p[]记录质数,m[]记录幂次

int main(){

	LL n;

	int i,j,ans=0;

	scanf("%lld",&n);

	for(i=2;(LL)i*i<=n;i++)//注意此处不能写成for(i=2;i*i<=n;i++)

		if(n%i==0){

			p[++tot]=i;

			while(n%i==0)n/=i,m[tot]++;

		}

	if(n>1)p[++tot]=n,m[tot]=1;

	for(i=1;i<=tot;i++){

		j=1;

		while(1){

			if(m[i]>=j)ans++,m[i]-=j;

			else break;

			j++;

		}

	}

	printf("%d\n",ans);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

//動画解説写し

struct Sieve{

  int n;

  vector<int>f,primes;

  Sieve(int n=1):n(n),f(n+1){

  /*  f[0]=f[1]=-1;

    for(long long i=2;i<=n;++i){

      if(f[i])continue;

      primes.push_back(i);

      f[i]=i;

      for(long long j=i*i;j<=n;j+=i){

        if(!f[j])f[j]=i;

      }

    }*/

  }

vector<pair<long long,int>>factor(long long x){

  vector<pair<long long,int>>res;

  for(long long i=2;i*i<=x;++i){

    int y=0;

    while(x%i==0){

      x/=i;

      ++y;

    }

    if(y!=0)res.emplace_back(x,y);

  }

  if(x!=1)res.emplace_back(x,1);

  return res;

}

};

int main(){

  long long n;

  cin>>n;

  Sieve s(1000005);

  auto fs=s.factor(n);

  int ans=0;

  for(auto p:fs){

    int x=p.second;

    int b=1;

    while(b<=x){

      x-=b;

      b++;

      ++ans;

    }

  }

  cout<<ans<<endl;

  return 0;

}

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

using namespace std;

//

struct Sieve{

  vector<pair<long long,int>>factor(long long x){//素因数分解（素数、何個あるか）

    vector<pair<long long,int>>res;

    for(long long i=2;i*i<=x;++i){

      int y=0;

      while(x%i==0){

        x/=i;

        ++y;

      }

      if(y!=0)res.emplace_back(x,y);

    }

    if(x!=1)res.emplace_back(x,1);

    return res;

  }

};

int main(){

  long long n;

  cin>>n;

  Sieve s;

  auto fs=s.factor(n);

  int ans=0;

  for(auto p:fs){

    int x=p.second;

    int b=1;

    while(b<=x){

      x-=b;

      b++;

      ++ans;

    }

  }

  cout<<ans<<endl;

  return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define ull unsigned long long int

int main() {



	ull N; cin >> N;

	int ans = 0;

	for(int i=2;i<=1000000;++i) {

		int cur = 0;

		while (N % i == 0) {

			cur++;

			N /= i;

		}

		for(int j=1;j<=cur;++j) {

			if (cur < j) break;

			ans++; cur -= j;

		}

	}

	if (N > 1) ans++;

	cout << ans << endl;



	return 0;

}


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

using namespace std;

#define ull unsigned long long int

int main() {

 

	ull N; cin >> N;

	int ans = 0;

	for(int i=2;i*1LL*i<=N;++i) {

		int cur = 0;

		while (N % i == 0) {

			cur++;

			N /= i;

		}

		for(int j=1;j<=cur;++j) {

			if (cur < j) break;

			ans++; cur -= j;

		}

	}

	if (N > 1) ans++;

	cout << ans << endl;

 

	return 0;

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 11.505330296147521x):
#include<stdio.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};

LL N;

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;

}

int main(void)

{

  int i,x=0;

  long long a=0,N;

  N=IN();

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;(LL)i*i<=N;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.1800835981670528x):
#include<stdio.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};

LL N;

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;

}

int main(void)

{

  int i,x=0;

  long long a=0,N;

  N=IN();

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;(LL)i*i<=N;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 12.70508629665468x):
#include<stdio.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};

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;

}

int main(void)

{

  int x=0;LL a=0,i,N=IN();

  while(N%2==0){x++;N/=2;}a+=e[x],x=0;

  while(N%3==0){x++;N/=3;}a+=e[x],x=0;

  while(N%5==0){x++;N/=5;}a+=e[x];

  for(i=6;i*i<=N;i+=6)

  {

    x=0;while(N%(i+1)==0){x++,N/=i+1;}a+=e[x];

    x=0;while(N%(i+5)==0){x++,N/=i+5;}a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.303140680541739x):
#include<stdio.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};

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;

}

int main(void)

{

  int x=0;LL a=0,i,N=IN();

  while(N%2==0){x++;N/=2;}a+=e[x],x=0;

  while(N%3==0){x++;N/=3;}a+=e[x],x=0;

  while(N%5==0){x++;N/=5;}a+=e[x];

  for(i=6;i*i<=N;i+=6)

  {

    x=0;while(N%(i+1)==0){x++,N/=i+1;}a+=e[x];

    x=0;while(N%(i+5)==0){x++,N/=i+5;}a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 9.82449375605561x):
#include<stdio.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};

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 BinaryModularPower(LL x,LL y,LL mod)

{int z=y&1;LL p=x,v=1;while(y){if(y&1){v=(v*p)%mod;}p=(p*p)%mod;y>>=1;}return v;}

int Prime(LL a,LL b,LL x,LL mod)

{

  LL y=BinaryModularPower(a,b,x);

  if(y==1)return 1;

  while(x){if(y+1==mod){return 1;}y=(y*y)%mod;x--;}

  return 0;

}

int main(void)

{

  LL a=0,i=3,p=2,N=IN();

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

  while(p*p<N)

  {

    int count=0;LL y=i>>1,loop=1;

    while(!(N%p)){count++,N/=p;}a+=e[count];

    if(i==3||i==5||i==7||i==11){p++;continue;}

    while(!(y&1)){y>>=1;loop++;}

    if(Prime(2,y,loop,i)&&Prime(3,y,loop,i)&&

       Prime(5,y,loop,i)&&Prime(7,y,loop,i)&&Prime(11,y,loop,i)){p++;}

    i+=2;

  }

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

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.0076828429426248x):
#include<stdio.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};

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 BinaryModularPower(LL x,LL y,LL mod)

{int z=y&1;LL p=x,v=1;while(y){if(y&1){v=(v*p)%mod;}p=(p*p)%mod;y>>=1;}return v;}

int Prime(LL a,LL b,LL x,LL mod)

{

  LL y=BinaryModularPower(a,b,x);

  if(y==1)return 1;

  while(x){if(y+1==mod){return 1;}y=(y*y)%mod;x--;}

  return 0;

}

int main(void)

{

  LL a=0,i=3,p=2,N=IN();

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

  while(p*p<N)

  {

    int count=0;LL y=i>>1,loop=1;

    while(!(N%p)){count++,N/=p;}a+=e[count];

    if(i==3||i==5||i==7||i==11){p++;continue;}

    while(!(y&1)){y>>=1;loop++;}

    if(Prime(2,y,loop,i)&&Prime(3,y,loop,i)&&

       Prime(5,y,loop,i)&&Prime(7,y,loop,i)&&Prime(11,y,loop,i)){p++;}

    i+=2;

  }

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

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 9.82449375605561x):
#include<stdio.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};

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 BinaryModularPower(LL x,LL y,LL mod)

{LL p=x,v=1;while(y){if(y&1){v=(v*p)%mod;}p=(p*p)%mod;y>>=1;}return v;}

int Prime(LL a,LL b,LL x,LL mod)

{

  LL y=BinaryModularPower(a,b,x);

  if(y==1)return 1;

  while(x){if(y+1==mod){return 1;}y=(y*y)%mod;x--;}

  return 0;

}

int main(void)

{

  LL a=0,i=3,p=2,N=IN();

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

  while(p*p<N)

  {

    int count=0;LL y=i>>1,loop=1;

    while(!(N%p)){count++,N/=p;}a+=e[count];

    if(i==3||i==5||i==7||i==11){p++;continue;}

    while(!(y&1)){y>>=1;loop++;}

    if(Prime(2,y,loop,i)&&Prime(3,y,loop,i)&&

       Prime(5,y,loop,i)&&Prime(7,y,loop,i)&&Prime(11,y,loop,i)){p++;}

    i+=2;

  }

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

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.0076828429426248x):
#include<stdio.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};

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 BinaryModularPower(LL x,LL y,LL mod)

{LL p=x,v=1;while(y){if(y&1){v=(v*p)%mod;}p=(p*p)%mod;y>>=1;}return v;}

int Prime(LL a,LL b,LL x,LL mod)

{

  LL y=BinaryModularPower(a,b,x);

  if(y==1)return 1;

  while(x){if(y+1==mod){return 1;}y=(y*y)%mod;x--;}

  return 0;

}

int main(void)

{

  LL a=0,i=3,p=2,N=IN();

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

  while(p*p<N)

  {

    int count=0;LL y=i>>1,loop=1;

    while(!(N%p)){count++,N/=p;}a+=e[count];

    if(i==3||i==5||i==7||i==11){p++;continue;}

    while(!(y&1)){y>>=1;loop++;}

    if(Prime(2,y,loop,i)&&Prime(3,y,loop,i)&&

       Prime(5,y,loop,i)&&Prime(7,y,loop,i)&&Prime(11,y,loop,i)){p++;}

    i+=2;

  }

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

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 9.819836394083294x):
#include<stdio.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};

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 BinaryModularPower(LL x,LL y,LL mod)

{LL p=x,v=1;while(y){if(y&1){v=(v*p)%mod;}p=(p*p)%mod;y>>=1;}return v;}

int Prime(LL a,LL b,LL x,LL mod)

{

  LL y=BinaryModularPower(a,b,x);

  if(y==1)return 1;

  while(x){if(y+1==mod){return 1;}y=(y*y)%mod;x--;}

  return 0;

}

int main(void)

{

  LL a=0,i=3,p=2,N=IN();

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

  while(p*p<N)

  {

    int count=0;LL y=i>>1,loop=1;

    while(!(N%p)){count++,N/=p;}a+=e[count];

    if(i==3||i==5||i==7||i==11){p++;continue;}

    while(!(y&1)){y>>=1;loop++;}

    if(Prime(2,y,loop,i)&&Prime(3,y,loop,i)&&

       Prime(5,y,loop,i)&&Prime(7,y,loop,i)&&Prime(11,y,loop,i)){p++;}

    i+=2;

  }

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

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.0072051446642802x):
#include<stdio.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};

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 BinaryModularPower(LL x,LL y,LL mod)

{LL p=x,v=1;while(y){if(y&1){v=(v*p)%mod;}p=(p*p)%mod;y>>=1;}return v;}

int Prime(LL a,LL b,LL x,LL mod)

{

  LL y=BinaryModularPower(a,b,x);

  if(y==1)return 1;

  while(x){if(y+1==mod){return 1;}y=(y*y)%mod;x--;}

  return 0;

}

int main(void)

{

  LL a=0,i=3,p=2,N=IN();

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

  while(p*p<N)

  {

    int count=0;LL y=i>>1,loop=1;

    while(!(N%p)){count++,N/=p;}a+=e[count];

    if(i==3||i==5||i==7||i==11){p++;continue;}

    while(!(y&1)){y>>=1;loop++;}

    if(Prime(2,y,loop,i)&&Prime(3,y,loop,i)&&

       Prime(5,y,loop,i)&&Prime(7,y,loop,i)&&Prime(11,y,loop,i)){p++;}

    i+=2;

  }

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

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 12.853699632068105x):
#include<stdio.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};

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;

}

int main(void)

{

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

  while(N%2==0){x++;N/=2;}a+=e[x],x=0;

  while(N%3==0){x++;N/=3;}a+=e[x],x=0;

  while(N%5==0){x++;N/=5;}a+=e[x];

  while(q*q<=N)

  {

    p+=6,q+=6;

    x=0;while(!(N%p)){x++;N/=p;}a+=e[x];

    x=0;while(!(N%q)){x++;N/=q;}a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3183837161674963x):
#include<stdio.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};

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;

}

int main(void)

{

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

  while(N%2==0){x++;N/=2;}a+=e[x],x=0;

  while(N%3==0){x++;N/=3;}a+=e[x],x=0;

  while(N%5==0){x++;N/=5;}a+=e[x];

  while(q*q<=N)

  {

    p+=6,q+=6;

    x=0;while(!(N%p)){x++;N/=p;}a+=e[x];

    x=0;while(!(N%q)){x++;N/=q;}a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=1e6;i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 12.863264510148378x):
#include<stdio.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};

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;

}

int main(void)

{

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

  while(N%2==0){x++;N/=2;}a+=e[x],x=0;

  while(N%3==0){x++;N/=3;}a+=e[x];

  while(q*q<=N)

  {

    p+=6,q+=6;

    x=0;while(!(N%p)){x++;N/=p;}a+=e[x];

    x=0;while(!(N%q)){x++;N/=q;}a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

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

#include<math.h>

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};

int main(void)

{

  int i,x;

  long long a=0,N;

  x=scanf("%lld",&N)-1;

  while(N%2==0){x++;N/=2;}

  a+=e[x];

  for(i=3;i<=(int)sqrt(N);i+=2)

  {

    x=0;while(!(N%i))x++,N/=i;

    a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}

// Faster C++ solution for the same problem (measured speedup: 1.319364770639681x):
#include<stdio.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};

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;

}

int main(void)

{

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

  while(N%2==0){x++;N/=2;}a+=e[x],x=0;

  while(N%3==0){x++;N/=3;}a+=e[x];

  while(q*q<=N)

  {

    p+=6,q+=6;

    x=0;while(!(N%p)){x++;N/=p;}a+=e[x];

    x=0;while(!(N%q)){x++;N/=q;}a+=e[x];

  }

  if(N>1)a++;

  return printf("%lld\n",a),0;

}