super_log （广义欧拉降幂）（2019南京网络赛）

题目：

In Complexity theory, some functions are nearly O(1)O(1), but it is greater then O(1)O(1). For example, the complexity of a typical disjoint set is O(nα(n))O(nα(n)). Here α(n)α(n) is Inverse Ackermann Function, which growth speed is very slow. So in practical application, we often assume α(n) \le 4α(n)≤4.

However O(α(n))O(α(n)) is greater than O(1)O(1), that means if nn is large enough, α(n)α(n) can greater than any constant value.

Now your task is let another slowly function log*log∗ xx reach a constant value bb. Here log*log∗ is iterated logarithm function, it means “the number of times the logarithm function iteratively applied on xx before the result is less than logarithm base aa”.

Formally, consider a iterated logarithm function log_{a}^*loga∗​

Find the minimum positive integer argument xx, let log_{a}^* (x) \ge bloga∗​(x)≥b. The answer may be very large, so just print the result xx after mod mm.

Input

The first line of the input is a single integer T(T\le 300)T(T≤300) indicating the number of test cases.

Each of the following lines contains 33 integers aa, bb and mm.

1 \le a \le 10000001≤a≤1000000

0 \le b \le 10000000≤b≤1000000

1 \le m \le 10000001≤m≤1000000

Note that if a==1, we consider the minimum number x is 1.

Output

For each test case, output xx mod mm in a single line.

Hint

In the 4-th4−th query, a=3a=3 and b=2b=2. Then log_{3}^* (27) = 1+ log_{3}^* (3) = 2 + log_{3}^* (1)=3+(-1)=2 \ge blog3∗​(27)=1+log3∗​(3)=2+log3∗​(1)=3+(−1)=2≥b, so the output is 2727 mod 16 = 1116=11.

样例输入复制

5
2 0 3
3 1 2
3 1 100
3 2 16
5 3 233

样例输出复制

1
1
3
11
223

解题报告：严重怀疑这场比赛的出题方，读题实在是太困难了，看了半个小时才理解了要求解什么东西，一看就是一个广义欧拉降幂，然后就直接去写的之前的模板，求解无穷个2的幂次，
但是修修改改的过了样例，但是忘记了广义欧拉降幂的实现，疯狂wa，在比赛结束后找了好久才发现是没有去使用广义欧拉降幂的性质，忘记在该加欧拉（m）的地方进行加了，隔壁队的
数论手，给了一个能够实现这个功能的快速幂，稍微一修改就A了。这个需要掌握了，当时时间太紧，头脑已经混了。

ac代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
typedef long long ll;

const int maxn=1e7+10;
vector<int> prime;
int phi[maxn];

void db_Onion()
{
    phi[1]=1;
    for(int i=2;i<maxn;i++)
    {
        if(phi[i]==0)
        {
            prime.push_back(i);
            phi[i]=i-1;
        }
        for(int j=0;j<prime.size()&&prime[j]*i<maxn;j++)
        {
            if(i%prime[j]==0)
            {
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else
            {
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
            }
        }
    }
}
ll a,b,m;
ll cal(ll x,ll m)
{
    if(x<m)
        return x;
    else
        return x%m+m;
}

ll ans;

ll ksm(ll r,ll n,ll m)
{
    ll d=r,ans=1;
    bool f=0;
    if(r==0&&n==0)return 1;
    while(n){
        if(n&1){
            ans=ans*d;
            if(ans>=m){
                ans%=m;f=1;
            }
        }
        d=d*d;
        if(n>1&&d>=m){
            d%=m;f=1;
        }
        n>>=1;
    }
    if(f)ans+=m;
    return ans;
}
ll slove(ll p,int tot)
{
    if(tot==b+1)
        return 1;
    if(p==1)
        return 1;
    
    ll tmp=slove(phi[p],tot+1); 
    return ksm(a,tmp,p);        
}

int main()
{
    db_Onion();
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%lld%lld%lld",&a,&b,&m);
        if(b==0||a==1)
        {
            printf("%lld\n",1%m);
            continue;
        }
        ans=0;
        printf("%lld\n",slove(m,1)%m);
    }
}