#include<iostream>
#include<cstring>
#include<vector>
#include<random>
#include<map>
#include<unordered_map>
#include<algorithm>
using namespace std;
using LL = long long;
const int s = 9;
// n < 2^78
const LL p[9] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
mt19937_64 rnd(random_device{}());

LL mul(LL a, LL b, LL p){
    // return __int128(a) * b % p;
    a %= p, b %= p;
    LL c = (long double)a * b / p;
    LL ans = a * b - c * p;
    if (ans < 0)
        ans += p;
    else if (ans >= p)
        ans -= p;
    return ans;
}

LL qpow(LL a, LL n, LL p){
    LL ans = 1;
    a %= p;
    while (n){
        if (n & 1) ans = mul(ans, a, p);
        a = mul(a, a, p);
        n >>= 1;
    }
    return ans;
}

bool check(LL a, LL n, LL x, LL t){
    LL ret = qpow(a, x, n);
    LL last = ret;
    for (int i = 1; i <= t; i++){
        ret = mul(ret, ret, n);
        if (ret == 1 && last != 1 && last != n - 1)
            return true;
        last = ret;
    }
    if (ret != 1) return true;
    else return false;
}

bool Miller_Rabin(LL n){
    if (n < 2) return false;
    for(auto x : p) if (n == x) return true;
    if ((n & 1) == 0) return false;

    LL x = n - 1;
    LL t = 0;
    while ((x & 1) == 0){
        x >>= 1;
        t++;
    }

    for (int i = 0; i < s; i++){
        // LL a = uniform_int_distribution<LL>(1, n - 1)(rnd);
        // if (check(a, n, x, t))
        if (check(p[i], n, x, t)) return false;
    }
    return true;
}


LL Pollard_rho(LL x){
    LL s = 0, t = 0, c = uniform_int_distribution<LL>(1, x - 1)(rnd);
    LL step = 0, goal = 1;
    LL val = 1;
    for (goal = 1;; goal <<= 1, s = t, val = 1){
        for (step = 1; step <= goal; ++step){
            t = (mul(t, t, x) + c) % x;
            val = mul(val, abs(t - s), x);
            if ((step % 127) == 0){
                LL d = __gcd(val, x);
                if (d > 1)
                    return d;
            }
        }
        LL d = __gcd(val, x);
        if (d > 1) return d;
    }
}
LL fac[200], tot;

void findfac(LL n){
    if (n == 1) return;
    if (Miller_Rabin(n)){
        fac[++tot] = n;
        return;
    }
    LL p = n;
    while (p >= n) p = Pollard_rho(n);
    while (n % p == 0) n /= p;
    findfac(n);
    findfac(p);
}

void dfs(int u, LL val, const vector<pair<LL, int> > &pri, vector<LL> &f){
   if (u == pri.size()){
       f.push_back(val);
       return;
   }
   int c = pri[u].second;
   for(int i = 0; i <= c; i++){
       dfs(u + 1, val, pri, f);
       val *= pri[u].first;
   }
}

auto go_fac(LL n){ 
   tot = 0;
   if (n > 1) findfac(n);     
   map<LL, int> mp;
   vector<pair<LL, int> > pri;
   for(int i = 1; i <= tot; i++){
       if (mp.contains(fac[i])) continue;
       int c = 0;
       while(n % fac[i] == 0) c += 1, n /= fac[i];
       mp[fac[i]] = c;
   }
   for(auto x : mp) pri.push_back(x);
   vector<LL> f;
   dfs(0, 1, pri, f);
   sort(f.begin(), f.end());
   return make_pair(f, pri);
}

LL qpow2(LL a, LL b, LL p){
    a %= p;
    LL ans = 1;
    while(b){
        if (b & 1) ans = ans * a % p;
        b >>= 1;
        a = a * a % p;
    }
    return ans;
}

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int T;
    cin >> T;
    while(T--){
        LL n, m, p;
        cin >> n >> m >> p;
        auto [factor, primes] = go_fac(n);
        const int s = factor.size();
        
        unordered_map<LL, int> mp;
        for(int i = 0; i < s; i++){
            mp[factor[i]] = i;
        }

        auto solve = [&](LL len){
            return qpow2(m, (len + 1) / 2, p);
        };

        vector<LL> f(s);
        for(int i = 0; i < s; i++){
            f[i] = solve(factor[i]);
        }
        for(auto [pri, _] : primes){
            for(int i = s - 1; i >= 0; i--){
                if (factor[i] % pri == 0){
                    f[i] -= f[mp[factor[i] / pri]];
                    if (f[i] < 0) f[i] += p;
                }
            }
        }
        LL ans = 0;
        for(int i = 0; i < s; i++){
            if (factor[i] % 2 == 0){
                ans += f[i] * (factor[i] / 2 % p) % p;
            }
            else{
                ans += f[i] * (factor[i] % p) % p;
            }
        }
        cout << ans % p << '\n';
    }

}