很容易想到我們要列舉GCD，然後用每一個數除以它，再連乘，得到公約數含這個數的方案數。然後再用容斥原理減掉多餘的部分。

但是問題就在，如果一個一個算的話，複雜度是min（Ai）* n，達到了1e10的複雜度，肯定不行。

如果我們用篩數的方法來列舉每一個除數，就能很快的算出來（類似素數篩，nlogn）。這個篩法的思路是：我們計算被除數中滿足當前除數的情況下，商為k的數的個數，然後把它們乘起來。

最後用一次容斥原理，算出結果。

程式碼如下：

#include<queue>
#include<cmath>
#include<stack>
#include<cstdio>
 

#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
#define INF 0x3f3f3f3f
#define CLR(a,b) memset(a,b,sizeof(a))
#define PI acos(-1.0)
#define MAX 100000
const LL MOD = 1e9 + 7;
LL ant[MAX+5];      //數字出現的次數 
LL num[MAX+5
 
];      //數字的字首和
LL dp[MAX+5];       //記錄每個GCD的方案數 
LL QuickMod(LL a,LL b)
{
    LL ans = 1;
    while (b)
    {
        if (b & 1)
            ans = ans * a % MOD;
        a = a*a % MOD;
        b >>= 1;
    }
    return ans;
}
int main()
{
    int T;
    int Case = 1;
    int n;
    int minn;
    scanf
 
 ("%d",&T);
    while (T--)
    {
        minn = INF;
        scanf ("%d",&n);
        CLR(ant,0);
        while (n--)
        {
            int t;
            scanf ("%d",&t);
            minn = min(minn,t);
            ant[t]++;       //統計每個數的個數 
        }
        for (int i = 1 ; i <= MAX ; i++)        //求字首和 
            num[i] = num[i-1] + ant[i];
        for (int i = 2 ; i <= MAX ; i++)        //列舉除數 
        {
            if (i > minn)       //記得這個，剛開始就是因為沒有初始化dp才錯的 
            {
                dp[i] = 0;
                continue;
            }
            dp[i] = 1;
            for (int j = 0 ; j <= MAX ; j += i)     //求出各段的商的積 
            {
                LL a,b;     //商，個數
                a =  j / i;
                if (j == 0)     //直接得出 
                    b = 0;
                else if (i+j-1 > MAX)       //超過上限 
                    b = num[MAX] - num[j-1];
                else        //利用字首和計算出中間數字的個數 
                    b = num[i+j-1] - num[j-1];
                dp[i] = dp[i] * QuickMod(a,b) % MOD;
            }
        }
        LL ans = 0;
        for (int i = MAX ; i >= 2 ; i--)        //利用容斥原理求結果 
        {
            for (int j = i+i ; j <= MAX ; j += i)
            {
                dp[i] = (dp[i] - dp[j] + MOD) % MOD;
            }
            ans = (ans + dp[i]) % MOD;
        }
        printf ("Case #%d: %lld\n",Case++,ans);
    }
    return 0;
}