Declare:
k=∑mi=1φ(i∗n)mod1000000007

n is a square-free number.

φ is the Euler's totient function.

find:
ans=kkkk...kmodp

There are infinite number of k
Input Multiple test cases(test cases ≤100), one line per case.

Each line contains three integers, n,m and p.

1≤n,m,p≤107

Output For each case, output a single line with one integer, ans.
Sample Input 1 2 6 1 100 9
Sample Output 4 7

題意：只要是那個k是無限個

題解：首先是算k：先了解兩條性質，尤拉函式是積性函式；

（1）積性函式性質：F(m1*m2)=F(m1)*F(m2)，當且近當gcd(m1,m2)=1時成立；

（2），其中p是n的素因子。這個用尤拉函式的素因子表示式很好證明。

有了這個再來算k，題目的n是很特殊的，它的每個素因子的冪次都是1：

那麼假設素數p是n的一個素因子，顯然gcd(p,n/p)=1;關鍵是i，如果i中沒有素因子p，那麼就直接用積性性質。如果i%p==0，必然可以寫成i=k*p;即倍數關係，否則i%p!=0;

所以分成兩部分求：

.....p是素數,素數的尤拉值就是p-1;

到這裡前兩和式是可以合併的，考慮和式的上下限，含義不同，第二項的i表示的p的倍數i*p才是第一項i的含義，相當於第二項剛好把第一項補齊了，那麼從1到m沒有遺漏，而且第二項的i用第一項替換后里面也是n/p;最終

這是個二元遞迴式：n/p和m/p看成整體,那麼設原先求的為f(n,m)，所以f(n,m)=(p的尤拉值)*f(n/p,m)+f(n,m/p);

每次列舉一個就夠了，n每次要除以p，最多就是把它的每個素因子除完。

第二部分k的超級冪：用尤拉的定理：指數迴圈節

每次往冪次上一層模就取一次尤拉值,只有1的尤拉值等一自己,其他數的尤拉值都是小於自己的，所以模會不斷變小至1，顯然對1取模結果就是0，所以無限就變得有限了

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<utility>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<iterator>
#include<stack>
using namespace std;
const int INF=1e9+7;
const double eps=1e-7;
const int N=1e7+5;
const int M=1000000007;
typedef long long ll;
int pri[N],phi[N];
bool vis[N];
int tot;
ll sum[N];
void init()
{
    int n=N;
    tot=0;
    memset(vis,false,sizeof vis);
    phi[1]=1;
    for(int i=2;i<n;i++)
    {
        if(!vis[i])
        {
            pri[tot++]=i;
            phi[i]=i-1;
        }
        for(int j=0;j<tot && i*pri[j]<n;j++)
        {
            vis[i*pri[j]]=true;
            if(i%pri[j]==0)
            {
                phi[i*pri[j]]=phi[i]*pri[j];
                break;
            }
            else phi[i*pri[j]]=phi[i]*(pri[j]-1);
        }
    }
    sum[0]=0;
    for(int i=1;i<N;i++)
        sum[i]=(sum[i-1]+phi[i])%M;
}
ll Pow(ll a,ll n,ll mod)
{
    ll ans=1;
    while(n)
    {
        if(n&1)
        {
            ans=ans*a%mod;
//            if(ans>=mod)ans=ans%mod;
        }
        a=a*a%mod;
//        if(a>=mod) a=a%mod;
        n>>=1;
    }
    if(ans==0) ans+=mod;
    return ans;
}
ll solve(ll k,ll mod)
{
    if(mod==1) return mod;
    ll tmp=phi[mod];
    ll up=solve(k,tmp);
    ll ans=Pow(k,up,mod);
    return ans;
}
int rear;
int a[15];
void resolve(ll n)
{
    for(int i=0;i<tot;i++)
    {
        if(!vis[n]) {a[rear++]=n;break;}
        if(n%pri[i]==0)
        {
            a[rear++]=pri[i];
            n/=pri[i];
        }
    }
}
ll f(int pos,ll n,ll m)
{
    //pos即每個素數，一次一個就行了
    if(n==1) return sum[m];//n為1結果就是尤拉值的字首和
    if(m==0)return 0;
    return ((a[pos]-1)*f(pos-1,n/a[pos],m)%M+f(pos,n,m/a[pos]))%M;
}
int main()
{
    init();//打表
    ll n,m,p;
    while(~scanf("%I64d%I64d%I64d",&n,&m,&p))
    {
        rear=0;
        resolve(n);//素因子分解
        ll k=f(rear-1,n,m);//算k
        ll ans=solve(k,p);
        printf("%I64d\n",ans%p);
    }
    return 0;
}