#include<bits/stdc++.h>
using namespace std;
const int BS = 400;
long long mod = 1e18;
namespace Math
{
    inline int pw(int base, int p, const int mod)
    {
        static int res;
        for (res = 1; p; p >>= 1, base = static_cast<long long>(base) * base % mod)
            if (p & 1)
                res = static_cast<long long>(res) * base % mod;
        return res;
    }
    inline int inv(int x, const int mod) { return pw(x, mod - 2, mod); }
}

const int mod1 = 998244353, mod2 = 1004535809, mod3 = 469762049, G = 3;
const long long mod_1_2 = static_cast<long long>(mod1) * mod2;
const int inv_1 = Math::inv(mod1, mod2), inv_2 = Math::inv(mod_1_2 % mod3, mod3);
struct Int
{
    int A, B, C;
    explicit inline Int() {}
    explicit inline Int(int __num) : A(__num), B(__num), C(__num) {}
    explicit inline Int(int __A, int __B, int __C) : A(__A), B(__B), C(__C) {}
    static inline Int reduce(const Int &x)
    {
        return Int(x.A + (x.A >> 31 & mod1), x.B + (x.B >> 31 & mod2), x.C + (x.C >> 31 & mod3));
    }
    inline friend Int operator+(const Int &lhs, const Int &rhs)
    {
        return reduce(Int(lhs.A + rhs.A - mod1, lhs.B + rhs.B - mod2, lhs.C + rhs.C - mod3));
    }
    inline friend Int operator-(const Int &lhs, const Int &rhs)
    {
        return reduce(Int(lhs.A - rhs.A, lhs.B - rhs.B, lhs.C - rhs.C));
    }
    inline friend Int operator*(const Int &lhs, const Int &rhs)
    {
        return Int(static_cast<long long>(lhs.A) * rhs.A % mod1, static_cast<long long>(lhs.B) * rhs.B % mod2, static_cast<long long>(lhs.C) * rhs.C % mod3);
    }
    inline int get()
    {
        long long x = static_cast<long long>(B - A + mod2) % mod2 * inv_1 % mod2 * mod1 + A;
        return (static_cast<long long>(C - x % mod3 + mod3) % mod3 * inv_2 % mod3 * (mod_1_2 % mod) % mod + x) % mod;
    }
};

#define maxn 500005
#define N (maxn << 1)
namespace Poly
{
    int lim, s, rev[N];
    Int Wn[N | 1];
    inline void init(int n)
    {
        s = -1, lim = 1;
        while (lim < n)
            lim <<= 1, ++s;
        for (int i = 1; i < lim; ++i)
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << s;
        const Int t(Math::pw(G, (mod1 - 1) / lim, mod1), Math::pw(G, (mod2 - 1) / lim, mod2), Math::pw(G, (mod3 - 1) / lim, mod3));
        *Wn = Int(1);
        for (Int *i = Wn; i != Wn + lim; ++i)
            *(i + 1) = *i * t;
    }
    inline void NTT(Int *A, const int op = 1)
    {
        for (int i = 1; i < lim; ++i)
            if (i < rev[i])
                swap(A[i], A[rev[i]]);
        for (int mid = 1; mid < lim; mid <<= 1)
        {
            const int t = lim / mid >> 1;
            for (int i = 0; i < lim; i += mid << 1)
            {
                for (int j = 0; j < mid; ++j)
                {
                    const Int W = op ? Wn[t * j] : Wn[lim - t * j];
                    const Int X = A[i + j], Y = A[i + j + mid] * W;
                    A[i + j] = X + Y, A[i + j + mid] = X - Y;
                }
            }
        }
        if (!op)
        {
            const Int ilim(Math::inv(lim, mod1), Math::inv(lim, mod2), Math::inv(lim, mod3));
            for (Int *i = A; i != A + lim; ++i)
                *i = (*i) * ilim;
        }
    }
#undef N
}
Int A[1000005], B[1000005];
int n,q;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin>>n>>q;
    vector<int>to(n+1);
    vector<int>vis(n+1,0);
    vector<vector<long long>>b;
    vector<vector<long long>>c(BS,vector<long long>(BS));
    for(int i=1;i<=n;i++)cin>>to[i];
    for(int i=1;i<=n;i++)
    if(!vis[i])
    {
        vector<int>tmp;
        for(int j=i;!vis[j];j=to[j])
        {
            vis[j]=1;
            tmp.push_back(j);
        }
        if(tmp.size()<BS)
        {
            int siz=tmp.size();
            for(int j=0;j<siz;j++)
            for(int k=0;k<siz;k++)
            {
                int t=(k<j?k+siz-j:k-j);
                c[siz][t]+=tmp[j]*1ll*tmp[k];
            }
        }
        else 
        {
            vector<long long>ss;
            int siz=tmp.size();
            Poly::init(3*siz);
            for(int j=0;j<Poly::lim;j++)A[j]=B[j]=Int(0);
            for(int j=0;j<siz;j++)A[j]=Int(tmp[j]);
            for(int j=siz;j<2*siz;j++)A[j]=Int(tmp[j-siz]);
            for(int j=0;j<siz;j++)B[j]=Int(tmp[siz-1-j]);
            Poly::NTT(A),Poly::NTT(B);
            for(int j=0;j<Poly::lim;j++)A[j]=A[j]*B[j];
            Poly::NTT(A,0);
            for(int j=siz-1;j<2*siz-1;j++)ss.push_back(A[j].get());
            b.push_back(ss);
        }
    }
    while(q--)
    {
        long long ans=0;
        int k;
        cin>>k;
        for(int i=1;i<BS;i++)ans+=c[i][k%i];
        for(auto &i:b)ans+=i[k%i.size()];
        cout<<ans<<'\n';
    }

}