#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define read(x,y) scanf("%d%d",&x,&y)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
const int  maxn =1e5+5;
const int mod=(1<<31)-1;
ll gcd(ll x,ll y){return y==0?x:gcd(y,x&y);}
ll powmod(ll x,ll y){ll ret;for(ret=1;y;y>>=1,x=x*x) if(y&1) ret=ret*x; return ret;}
/*
題目大意：給定一個矩形數字，設定一個二元函式約數和函式，
求二元矩陣函式約數和之和，要求統計數表中約束和小於a的權值。

先不管限制，把公式化簡，老方法列舉gcd。
最終的形式是sigma T:1~n n/T*m/T* sigma d|T F(d)*miu(T/d)。
這時候再考慮限制，想想它要求F函式小於a，
而答案累加的過程中需要累積d|T，所以我們想到，建立一個反射，
F(d)->d,使得在保持F(d)在限制中 時候，可以更新d的倍數來統計答案，
我們先把查詢離線並按限制a從小到大排序，然後在結構體中，
建立約束和——d，和d——約束和的對映關係，
有了這個後我們就可以對於滿足限制的d，
列舉其倍數，對於倍數的G函式，d都有一次貢獻，所以丟到樹狀陣列中。
最終我們用樹狀陣列統計G函式的字首和
G(T)=sigma d|T F(d)*miu(T/d)。
最後一個小細節就是取模這題可以用與位運算。
*/
///篩法篩莫比烏斯函式和約數和函式
int prim[maxn],tot=0;
int vis[maxn],miu[maxn],s[maxn];
struct dsum
{
    int sd,id;
    bool operator<(const dsum& y) const
    {
        return sd<y.sd;
    }
}d[maxn];
void sieve()
{
    miu[1]=d[1].id=d[1].sd=1;
    for(int i=2;i<maxn;i++)
    {
        d[i].id=i;
        if(vis[i]==0)
        {
            prim[tot++]=i;
            miu[i]=-1;
            d[i].sd=i+1;
            s[i]=1;///最小質因子的冪數
        }
        for(int j=0;j<tot;j++)
        {
            if(1LL*i*prim[j]>=maxn) break;
            int k=i*prim[j];
            vis[k]=1;
            if(i%prim[j])
            {
                miu[k]=-miu[i];
               d[k].sd=d[i].sd*(prim[j]+1);
               s[k]=1;
            }
            else
            {
                s[k]=s[i]+1;
                int tmp=powmod(prim[j],s[i]+1);
                d[k].sd=d[i].sd*(prim[j]-1)/(tmp-1)*(tmp*prim[j]-1)/(prim[j]-1);
                break;
            }
        }
    }
    sort(d+1,d+maxn);
}
///離線詢問結構
struct qy
{
    int id,a;
    int n,m;
    bool operator<(const qy& y) const
    {
        return a<y.a;
    }
}q[maxn];
int ans[maxn];
///樹狀陣列結構
int tree[maxn<<1];
int lowbit(int x)
{
    return x&(-x);
}
void add(int x,ll d)
{
    for(;x<maxn;tree[x]+=d,x+=lowbit(x));
}
int sum(int x)
{
    int ret=0;
    for(;x>0;ret+=tree[x],x-=lowbit(x));
    return ret;
}
int main()
{
    sieve();
    ///for(int i=1;i<10;i++) cout<<d[i]<<" ";puts("");
    int t;scanf("%d",&t);
    for(int i=0;i<t;i++)
    {
        scanf("%d%d%d",&q[i].n,&q[i].m,&q[i].a);
        if(q[i].n>q[i].m) swap(q[i].n,q[i].m);
        q[i].id=i;
    }
    sort(q,q+t);   int p=1;
    for(int i=0;i<t;i++)
    {
        while(p<maxn&&d[p].sd<=q[i].a)
        {
            for(int j=1;j*d[p].id<maxn;j++)
                add(j*d[p].id,1LL*d[p].sd*miu[j]);///更新其倍數,根據公式的形式
            p++;
        }
        int ret=0;
        for(int j=1,k;j<=q[i].n;j=k+1)
        {
            k=min(q[i].n/(q[i].n/j),q[i].m/(q[i].m/j));
            int tm=q[i].m/j,tn=q[i].n/j;
            ret+=tm*tn*(sum(k)-sum(j-1));
        }
        ans[q[i].id]=ret&mod;
    }
    for(int i=0;i<t;i++)
    {
        printf("%d\n",ans[i]);
    }
    return 0;
}
/*
1
100000 100000 20000
*/