const int N = 1010;

int n, a[N];

bool read() {
	if (!(cin >> n)) return false;
	forn(i, n) assert(cin >> a[i]);
	return true;
}

void solve() {
	int cnt = accumulate(a, a + n, 0);
	if (n == 1) puts(cnt == 1 ? "YES" : "NO");
	else puts(cnt == n - 1 ? "YES" : "NO");
}

string s;

bool read() {
	return !!getline(cin, s);
}

string symmetric = "AHIMOoTUVvWwXxY";
map<char, char> opposite = {{'p', 'q'}, {'q', 'p'}, {'d', 'b'}, {'b', 'd'}};

void solve() {
	forn(i, sz(s)) {
		if (symmetric.find(s[i]) != string::npos) {
			if (s[sz(s) - 1 - i] != s[i]) {
				puts("NIE");
				return;
			}
		} else if (opposite.count(s[i])) {
			if ((sz(s) & 1) && i == (sz(s) >> 1)) {
				puts("NIE");
				return;
			}
			if (s[sz(s) - 1 - i] != opposite[s[i]]) {
				puts("NIE");
				return;
			}
		} else {
			puts("NIE");
			return;
		}
	}
	puts("TAK");
}

string s;

bool read() {
	return !!getline(cin, s);
}

void solve() {
	int pos = int(find_if(all(s), [](char c) { return c != '0' && c != '.'; }) - s.begin());;
	size_t dot_pos = s.find('.');
	if (dot_pos == string::npos) {
		dot_pos = s.size();
	} else {
		s.erase(dot_pos, 1);
	}

	int expv = (int) dot_pos - pos;
	if (expv > 0) expv--;
	forn(t, 2) {
		while (s.back() == '0') s.pop_back();
		reverse(all(s));
	}
	if (sz(s) > 1) s.insert(1, ".");
	if (expv == 0) printf("%s\n", s.c_str());
	else printf("%sE%d\n", s.c_str(), expv);
}

const int N = 1200300;

int n, m;
int p[N];
pti a[N];

bool read() {
	if (!(cin >> n >> m)) return false;
	forn(i, n) {
		assert(scanf("%d", &p[i]) == 1);
		p[i]--;
	}
	forn(i, m) {
		assert(scanf("%d%d", &a[i].x, &a[i].y) == 2);
		a[i].x--, a[i].y--;
	}
	return true;
}

bool used[N];
vector<int> g[N];
vector<int> perm, pos;

void dfs(int v) {
	if (used[v]) return;
	used[v] = true;
	pos.pb(v);
	perm.pb(p[v]);

	for (auto to : g[v]) dfs(to);
}

int ans[N];

void solve() {
	forn(i, n) {
		g[i].clear();
		used[i] = false;
	}

	forn(i, m) {
		g[a[i].x].pb(a[i].y);
		g[a[i].y].pb(a[i].x);
	}

	int cnt = 0;
	forn(i, n)
		if (!used[i]) {
			cnt++;
			pos.clear();
			perm.clear();
			dfs(i);
			sort(all(pos));
			sort(all(perm), greater<int>());
			forn(j, sz(perm))
				ans[pos[j]] = perm[j];
		}

	forn(i, n) {
		if (i) putchar(' ');
		printf("%d", ans[i] + 1);
	}
	puts("");
}

const int N = 101;

int n;
li k;
li a[N];

bool read() {
	if (!(cin >> n >> k)) return false;
	forn(i, n) assert(cin >> a[i]);
	return true;
}

const int mod = 1000 * 1000 * 1000 + 7;

inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline void inc(int& a, int b) { a = add(a, b); }
inline int mul(int a, int b) { return int(a * 1ll * b % mod); }

int count(li x) {
	int ans = 0;
	while (x) {
		ans++;
		x &= x - 1;
	}
	return ans;
}

void mul(int a[N][N], int b[N][N], int n) {
	static int c[N][N];
	forn(i, n)
		forn(j, n) {
			c[i][j] = 0;
			forn(k, n) inc(c[i][j], mul(a[i][k], b[k][j]));
		}
	forn(i, n) forn(j, n) a[i][j] = c[i][j];
}

void bin_pow(int a[N][N], li b, int n) {
	static int ans[N][N];
	forn(i, n) forn(j, n) ans[i][j] = i == j;

	while (b) {
		if (b & 1) mul(ans, a, n);
		mul(a, a, n);
		b >>= 1;
	}

	forn(i, n) forn(j, n) a[i][j] = ans[i][j];
}

void solve() {
	static int a[N][N];
	memset(a, 0, sizeof(a));
	forn(i, n) {
		forn(j, n)
			a[i][j] = count(::a[i] ^ ::a[j]) % 3 == 0;
		a[i][n] = 1;
	}

	//forn(i, n + 1) clog << mp(a[i], n + 1) << endl;

	bin_pow(a, k, n + 1);

	int ans = 0;
	forn(i, n + 1) inc(ans, a[i][n]);
	cout << ans << endl;
}

const int N = 3100300;

int n, m;
int a[N], p[N];

bool read() {
	if (!(cin >> n)) return false;
	forn(i, n) assert(scanf("%d", &a[i]) == 1);
	assert(cin >> m);
	forn(i, m) assert(scanf("%d", &p[i]) == 1);
	return true;
}

int cnt[N];
li z[N];

void solve() {
	memset(cnt, 0, sizeof(cnt));

	forn(i, n) cnt[a[i]]++;

	fore(a, 1, N) {
		if (!cnt[a]) continue;
		for (int b = a; b < N; b += a) {
			if (b / a != a) z[b] += li(cnt[a]) * cnt[b / a];
			else z[b] += li(cnt[a]) * (cnt[a] - 1);
		}
	}

	fore(i, 1, N) z[i] += z[i - 1];

	forn(i, m) {
		li ans = li(n) * (n - 1) - z[p[i] - 1];
		printf("%lld\n", ans);
	}
}