math板

int n,s,cnt,pr[N],v[N],m[N],vis[N],ans,T;
//int a0,a1,b0,b1,c[N][2],tot;
int ph[M],sum[M],maxx=0,vv[M],prim[M];

namespace mymath
{
	void p(int nn)
	{
		fd(i,2,nn)
		{
			if(v[i]==0) v[i]=i,pr[++cnt]=i;
			fd(j,1,cnt)
			{
				if(pr[j]>v[i]||pr[j]>nn/i) break;
				v[pr[j]*i]=pr[j];
			}
		}
	}
	
	int Phi(int x)
	{
		int re=x;
		for(int i=2;i*i<=x;i=-~i)
		{
			if(x%i==0)
			{
				re=re/i*(i-1);
				while(x%i==0) x/=i;
			}
		}
		if(x>1) re=re/x*(x-1);
		return re;
	}
	
	bool check(int x)
	{
		fd(i,2,sqrt(x))
		{
			if(x%i==0)
			{
				return 0;
			}
		}
		return 1;
	}
	
	int qpow(int a,int nn)
	{
		int re=1;
		while(nn)
		{
			if(nn&1) re*=a;
			nn>>=1;
			a*=a;
		}
		return re;
	}
	
	int gcd(int x,int y)
	{
		if(!x%y) return y;
		return gcd(y,x%y);
	}
	
	int modpow(int a,int nn,int Mod)
	{
		int re=1;
		while(nn)
		{
			if(nn&1) re*=a,re%=Mod;
			nn>>=1;
			a*=a,a%=Mod;
		}
		return re%Mod;
	}
	
    inline int mul(int a,int b,int mod)
    {
        int res=0;
        while(b>0)
        {
            if(b&1) res=(res+a)%mod;
            a=(a+a)%mod;b>>=1;
        }
        return res%mod;
    }

    pair<int,int> exgcd(int x,int y,int &d)
    {
        if(!y) {d=x;return {1,0};}
        auto t=exgcd(y,x%y,d);
        return {t.second,t.first-x/y*t.second};
    }

    int exCRT(int nn,int a[],int b[])
    {
        int x=a[1],M=b[1];
        fd(i,2,nn)
        {
            int p=(a[i]-x%b[i]+b[i])%b[i],gcdd;
            auto ans=exgcd(M,b[i],gcdd);
            if(p%gcdd) return -1;
            int xx=ans.first;
            xx=mul(xx,p/gcdd,b[i]/gcdd);
            x=(x+M*xx),M*=b[i]/gcdd,x=(x%M+M)%M;
        }
        return (x%M+M)%M;
    }
	
	void euler(int nn)
	{
		int cntt=0;
		fd(i,2,nn)
		{
			if(vv[i]==0)
			{
				vv[i]=i;
				prim[++cntt]=i;
				ph[i]=i-1;
			}
			fd(j,1,cntt)
			{
				if(prim[j]>vv[i]||prim[j]>nn/i) break;
				vv[i*prim[j]]=prim[j];
				ph[i*prim[j]]=ph[i]*(i%prim[j]?prim[j]-1:prim[j]);
			}
			sum[i]=sum[i-1]+ph[i];
//			cout<<sum[i]<<endl;
		}
	}
    //组合数
    inline void preC(int nn,int mod)//PRE
    {
        fac[0]=inv[0]=1;
        for(int i=1;i<=nn;i=-~i)
            fac[i]=fac[i-1]*i%mod;
        inv[nn]=modpow(fac[nn],mod-2,mod);
        for(int i=nn;i>=2;i=~-i)
            inv[i-1]=inv[i]*i%mod;
    }

    inline int C(int n,int m,int mod)//组合数
    {
        if(m==0||n==m) return 1;
        if(n<m) return 0;
        return fac[n]*inv[m]%mod*inv[n-m]%mod;
    }

    inline int modC(int n,int m,int mod)//卢卡斯
    {
        if(m==0||n==m) return 1;
        if(n<m) return 0;
        return C(n%mod,m%mod,mod)%mod*modC(n/mod,m/mod,mod)%mod;
    }

}