Description
定義，其中n無平方因數，是尤拉函式
現給出n,m,p，求 ，式子中k有無窮個
Input
第一行為一整數T表示用例組數，每組用例佔一行包括三個整數n,m,p
(T<=100,1<=n,m,p<=10^7)
Output
對於每組用例，輸出ans
Sample Input
1 2 6
1 100 9
Sample Output
4
7
Solution
首先求k，需要用到尤拉函式的兩個性質：
1.若(n,m)=1，則有
2.若m是素數且m|n，則有
由這兩個性質有：

記solve(n,m)=,p為n的素因子，則有

當n=1時，solve(1,m)=

;
當m=1時，solve(n,1)=;
當m=0時，solve(n,0)=0;
這個遞迴求解最多遞迴n的素因子個數層，故可以在至多O(log n)的複雜度內求出k，下面來求ans
此處引入一個由尤拉定理衍生出的一個指數迴圈節定理

每次往上冪一層模數就取一次尤拉函式值，由於一個數的尤拉函式值一定小於自身，所以至多經過O(log p)次操作模數就變成了1，那麼上面的冪就沒有意義了，無限冪就變成了有限冪
Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
 

using namespace std;
typedef long long ll;
#define maxn 11111111
#define mod 1000000007ll
int euler[maxn],prime[maxn],sum[maxn],res;
void get_euler()
{
    memset(euler,0,sizeof(euler));
    euler[1]=1,sum[1]=1;
    res=0; 
    for(int i=2;i<maxn;i++)
    {
        if(!euler[i])
        {
            euler[i]=i-1
 
;
            prime[res++]=i;
        } 
        for(int j=0;j<res&&prime[j]*i<maxn;j++)
        {
            if(i%prime[j]) 
                euler[prime[j]*i]=euler[i]*(prime[j]-1);
            else
            {
                euler[prime[j]*i]=euler[i]*prime[j];
                break;
            }
        }
        sum[i]=(sum[i-1]+euler[i])%mod;
    }
}
int solve(int n,int m)
{
    if(n==1)return sum[m];
    if(m==1)return euler[n];
    if(m==0)return 0;
    for(int i=0;i<res;i++)
        if(n%prime[i]==0)
            return (1ll*(prime[i]-1)*solve(n/prime[i],m)%mod+solve(n,m/prime[i]))%mod;
}
ll mod_pow(ll a,ll b,int p)
{
    ll ans=1;
    while(b)
    {
        if(b&1)ans=ans*a%p;
        a=a*a%p;
        b>>=1;
    }
    return ans;
}
int deal(int k,int p)
{
    if(p==1)return 0;
    ll temp=deal(k,euler[p]);
    return mod_pow(k,temp+euler[p],p)%p;
}
int main()
{
    get_euler();
    int n,m,p;
    while(~scanf("%d%d%d",&n,&m,&p))
    {
        ll k=solve(n,m);
        int ans=deal(k,p);
        printf("%d\n",ans);
    }
    return 0;
}