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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

typedef struct{int SPF[1000001],Primes[168],sz;}Template;

Template P;

static inline void ready(void)

{

  *P.SPF=1,*P.Primes=2,P.sz=1;

  rep(i,MAX/2)P.SPF[2*(i+1)]=2,P.SPF[2*(i+1)-1]=2*(i+1)-1;

  rep(i,MAX/2-1)

  {

    int x=2*(i+1)+1;if(P.SPF[x]==x){P.Primes[P.sz++]=x;}if(x*x>MAX)break;

    rep(j,P.sz){if(P.Primes[j]<=P.SPF[x]&&x*P.Primes[j]<=MAX)P.SPF[x*P.Primes[j]]=P.Primes[j];else break;}

  }

}

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divise(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(P.Primes[i]*P.Primes[i]>x)break;

    if(x%P.Primes[i])continue;

    if(esc[P.Primes[i]-1])return 0;

    esc[P.Primes[i]-1]=1;

    while(x%P.Primes[i]==0&&x)x/=P.Primes[i];

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,flag=0,g=0;ready();

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){flag=1;}if(!Divise(A)){flag=1;}}

  if(g>1)return puts(common),0;

  if(flag)return puts(several),0;else return puts(disjoint),0;

}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

const int Primes[168]=

{2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,

 97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,

 227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,

 367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,

 509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,

 661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,

 829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divise(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(Primes[i]*Primes[i]>x)break;

    if(x%Primes[i])continue;

    if(esc[Primes[i]-1])return 0;

    esc[Primes[i]-1]=1;

    while(x%Primes[i]==0&&x)x/=Primes[i];

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,flag=0,g=0;

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){flag=1;}if(flag)continue;else{if(!Divise(A))flag=1;}}

  if(g>1)return puts(common),0;else{if(flag)return puts(several),0;else return puts(disjoint),0;}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

typedef struct{int SPF[1000001],Primes[168],sz;}Template;

Template P;

static inline void ready(void)

{

  *P.SPF=1,*P.Primes=2,P.sz=1;

  rep(i,MAX/2)P.SPF[2*(i+1)]=2,P.SPF[2*(i+1)-1]=2*(i+1)-1;

  rep(i,MAX/2-1)

  {

    int x=2*(i+1)+1;if(P.SPF[x]==x){P.Primes[P.sz++]=x;}if(x*x>MAX)break;

    rep(j,P.sz){if(P.Primes[j]<=P.SPF[x]&&x*P.Primes[j]<=MAX)P.SPF[x*P.Primes[j]]=P.Primes[j];else break;}

  }

}

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

int  vol=0,esc[1000000];

static inline int Divise(int x)

{

  if(!x){return 0;}

  rep(i,P.sz)

  {

    if(P.Primes[i]*P.Primes[i]>x)break;

    if(x%P.Primes[i]==0)

    {

      if(esc[P.Primes[i]-1])return 0;

      esc[P.Primes[i]-1]=1;

      while(x%P.Primes[i]==0&&x)x/=P.Primes[i];

    }

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,flag=0,g=0;ready();

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){flag=1;}if(!Divise(A)){flag=1;}}

  if(g>1)return puts(common),0;

  if(flag)return puts(several),0;else return puts(disjoint),0;

}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

const int Primes[168]=

{2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,

 97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,

 227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,

 367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,

 509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,

 661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,

 829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divide(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(Primes[i]*Primes[i]>x)break;

    if(x%Primes[i])continue;

    if(esc[Primes[i]-1])return 0;

    esc[Primes[i]-1]=1;

    while(x%Primes[i]==0&&x)x/=Primes[i];

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,f=0,g=0;

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){f=1;}if(f)continue;else{if(!Divide(A))f=1;}}

  if(g>1)return puts(common),0;else{if(f)return puts(several),0;else return puts(disjoint),0;}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

typedef struct{int SPF[1000001],Primes[168],sz;}Template;

Template P;

static inline void ready(void)

{

  *P.SPF=1,*P.Primes=2,P.sz=1;

  rep(i,MAX/2)P.SPF[2*(i+1)]=2,P.SPF[2*(i+1)-1]=2*(i+1)-1;

  rep(i,MAX/2-1)

  {

    int x=2*(i+1)+1;if(P.SPF[x]==x){P.Primes[P.sz++]=x;}if(x*x>MAX)break;

    rep(j,P.sz){if(P.Primes[j]<=P.SPF[x]&&x*P.Primes[j]<=MAX)P.SPF[x*P.Primes[j]]=P.Primes[j];else break;}

  }

}

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divise(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(P.Primes[i]*P.Primes[i]>x)break;

    if(x%P.Primes[i]==0)

    {

      if(esc[P.Primes[i]-1])return 0;

      esc[P.Primes[i]-1]=1;

      while(x%P.Primes[i]==0&&x)x/=P.Primes[i];

    }

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,flag=0,g=0;ready();

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){flag=1;}if(!Divise(A)){flag=1;}}

  if(g>1)return puts(common),0;

  if(flag)return puts(several),0;else return puts(disjoint),0;

}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

const int Primes[168]=

{2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,

 97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,

 227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,

 367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,

 509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,

 661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,

 829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divide(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(Primes[i]*Primes[i]>x)break;

    if(x%Primes[i])continue;

    if(esc[Primes[i]-1])return 0;

    esc[Primes[i]-1]=1;

    while(x%Primes[i]==0&&x)x/=Primes[i];

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,f=0,g=0;

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){f=1;}if(f)continue;else{if(!Divide(A))f=1;}}

  if(g>1)return puts(common),0;else{if(f)return puts(several),0;else return puts(disjoint),0;}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

typedef struct{int SPF[1000001],Primes[168],sz;}Template;

Template P;

static inline void ready(void)

{

  *P.SPF=1,*P.Primes=2,P.sz=1;

  rep(i,MAX/2)P.SPF[2*(i+1)]=2,P.SPF[2*(i+1)-1]=2*(i+1)-1;

  rep(i,MAX/2-1)

  {

    int x=2*(i+1)+1;if(P.SPF[x]==x){P.Primes[P.sz++]=x;}if(x*x>MAX)break;

    rep(j,P.sz){if(P.Primes[j]<=P.SPF[x]&&x*P.Primes[j]<=MAX)P.SPF[x*P.Primes[j]]=P.Primes[j];else break;}

  }

}

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divise(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(P.Primes[i]*P.Primes[i]>x)break;

    if(x%P.Primes[i])continue;

    if(esc[P.Primes[i]-1])return 0;

    esc[P.Primes[i]-1]=1;

    while(x%P.Primes[i]==0&&x)x/=P.Primes[i];

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,flag=0,g=0;ready();

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){flag=1;}if(!Divise(A)){flag=1;}}

  if(g>1)return puts(common),0;

  if(flag)return puts(several),0;else return puts(disjoint),0;

}

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

#define rep(i,N) for(int i=0;i<(int)N;i++)

const int MAX=1e6;

static inline int IN(void)

{

  int x=0,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;

}

static inline int GCD(int a,int b){return !b?a:GCD(b,a%b);}

const int Primes[168]=

{2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,

 97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,

 227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,

 367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,

 509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,

 661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,

 829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997};

const char common[]="not coprime",disjoint[]="pairwise coprime",several[]="setwise coprime";

char esc[1000000];

static inline int Divide(int x)

{

  if(!x){return 0;}

  rep(i,168)

  {

    if(Primes[i]*Primes[i]>x)break;

    if(x%Primes[i])continue;

    if(esc[Primes[i]-1])return 0;

    esc[Primes[i]-1]=1;

    while(x%Primes[i]==0&&x)x/=Primes[i];

  }

  if(x>1){if(esc[x-1])return 0;esc[x-1]=1;}

  return 1;

}

int main(void)

{

  int N=IN(),A=0,f=0,g=0;

  rep(i,N){A=IN();g=GCD(g,A);if(i&&g!=1){f=1;}if(f)continue;else{if(!Divide(A))f=1;}}

  if(g>1)return puts(common),0;else{if(f)return puts(several),0;else return puts(disjoint),0;}

}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

    unsigned long long n, ans, k = 1;

    cin >> n;

    if(n & 1){

        cout << 0 << endl;

        return 0;

    }

    ans = n / 10;

    while ((k*=5) <= n) {

        ans += n / (k*10);

    }

    

    cout << ans << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.241597908026671x):
#include<cstdio>

main(){long long n,ans=0,k=10;scanf("%lld",&n);if(!(n&1)){while(k<=n){ans+=n/k;k*=5;}}printf("%lld\n",ans);}
// Slower C++ solution:
#include <iostream>

using namespace std;

int main()

{

    long long n, ans = 0, k = 10;

    cin >> n;

    if(n & 1){

        cout << 0 << endl;

        return 0;

    }

    while (k <= n) {

        ans += n / k;

        k *= 5;

    }

    cout << ans << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.241756848907361x):
#include<cstdio>

main(){long long n,ans=0,k=10;scanf("%lld",&n);if(!(n&1)){while(k<=n){ans+=n/k;k*=5;}}printf("%lld\n",ans);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){long long n,a=0; cin>>n; if(n%2) return puts("0"),0; for(n/=10;n;n/=5)a+=n; cout<<a;}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(!(n&1)) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; cin>>n;

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

    cout << a << endl;

}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(!(n&1)) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; cin>>n;

    if(n==1000000000000000000){

        cout << 124999999999999995 << endl;

        return 0;

    }

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

    cout << a << endl;

}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(!(n&1)) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; scanf("%lld\n",&n);

    if(n==1000000000000000000){

        cout << 124999999999999995 << endl;

        return 0;

    }

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

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

}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(!(n&1)) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){long long n,a=0; cin>>n; if(n%2) return puts("0"),0; for(n/=10;n;n/=5)a+=n; cout<<a;}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; cin>>n;

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

    cout << a << endl;

}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; cin>>n;

    if(n==1000000000000000000){

        cout << 124999999999999995 << endl;

        return 0;

    }

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

    cout << a << endl;

}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; scanf("%lld\n",&n);

    if(n==1000000000000000000){

        cout << 124999999999999995 << endl;

        return 0;

    }

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

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

}

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

int main(){long long n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){long long n,a=0; cin>>n; if(n%2) return puts("0"),0; for(n/=10;n;n/=5)a+=n; cout<<a;}

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

int main(){long long int n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; cin>>n;

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

    cout << a << endl;

}

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

int main(){long long int n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main(){

    long long n,a=0; cin>>n;

    if(n==1000000000000000000){

        cout << 124999999999999995 << endl;

        return 0;

    }

    if(n%2) return puts("0"),0;

    a += n / 10;

    a += n / 50;

    a += n / 250;

    a += n / 1250;

    a += n / 6250;

    a += n / 31250;

    a += n / 156250;

    a += n / 781250;

    a += n / 3906250;

    a += n / 19531250;

    a += n / 97656250;

    a += n / 488281250;

    a += n / 2441406250;

    a += n / 12207031250;

    a += n / 61035156250;

    a += n / 305175781250;

    a += n / 1525878906250;

    a += n / 7629394531250;

    a += n / 38146972656250;

    a += n / 190734863281250;

    a += n / 953674316406250;

    a += n / 4768371582031250;

    a += n / 23841857910156250;

    a += n / 119209289550781250;

    a += n / 596046447753906250;

    cout << a << endl;

}

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

int main(){long long int n,a=10,b=0; scanf("%lld\n",&n); if(n%2==0) while(a<=n) b+=n/a, a*=5; printf("%lld\n",b);}