Problem: Mrs. Hudson hasn't made her famous pancakes for quite a while and finally she decided to make them again. She has learned m new recipes recently and she can't wait to try them. Those recipes are based on n special spices. Mrs. Hudson has these spices in the kitchen lying in jars numbered with integers from 0 to n - 1 (each spice lies in an individual jar). Each jar also has the price of the corresponding spice inscribed — some integer ai.

We know three values for the i-th pancake recipe: di, si, ci. Here di and ci are integers, and si is the pattern of some integer written in the numeral system with radix di. The pattern contains digits, Latin letters (to denote digits larger than nine) and question marks. Number x in the di-base numeral system matches the pattern si, if we can replace question marks in the pattern with digits and letters so that we obtain number x (leading zeroes aren't taken into consideration when performing the comparison). More formally: each question mark should be replaced by exactly one digit or exactly one letter. If after we replace all question marks we get a number with leading zeroes, we can delete these zeroes. For example, number 40A9875 in the 11-base numeral system matches the pattern "??4??987?", and number 4A9875 does not.

To make the pancakes by the i-th recipe, Mrs. Hudson should take all jars with numbers whose representation in the di-base numeral system matches the pattern si. The control number of the recipe (zi) is defined as the sum of number ci and the product of prices of all taken jars. More formally: <image> (where j is all such numbers whose representation in the di-base numeral system matches the pattern si).

Mrs. Hudson isn't as interested in the control numbers as she is in their minimum prime divisors. Your task is: for each recipe i find the minimum prime divisor of number zi. If this divisor exceeds 100, then you do not have to find it, print -1.

Input

The first line contains the single integer n (1 ≤ n ≤ 104). The second line contains space-separated prices of the spices a0, a1, ..., an - 1, where ai is an integer (1 ≤ ai ≤ 1018).

The third line contains the single integer m (1 ≤ m ≤ 3·104) — the number of recipes Mrs. Hudson has learned. 

Next m lines describe the recipes, one per line. First you are given an integer di, written in the decimal numeral system (2 ≤ di ≤ 16). Then after a space follows the si pattern — a string from 1 to 30 in length, inclusive, consisting of digits from "0" to "9", letters from "A" to "F" and signs "?". Letters from "A" to "F" should be considered as digits from 10 to 15 correspondingly. It is guaranteed that all digits of the pattern (including the digits that are represented by letters) are strictly less than di. Then after a space follows an integer ci, written in the decimal numeral system (1 ≤ ci ≤ 1018).

Please do not use the %lld specificator to read or write 64-bit integers in С++, in is preferred to use cin, cout, strings or the %I64d specificator instead.

Output

For each recipe count by what minimum prime number the control number is divided and print this prime number on the single line. If this number turns out larger than 100, print -1.

Examples

Input

1
1
1
2 ? 1


Output

2


Input

4
2 3 5 7
4
2 ?0 11
2 ?1 13
2 0? 17
2 1? 19


Output

3
2
23
2


Input

1
1000000000000000000
1
16 ?????????????? 1


Output

-1

Note

In the first test any one-digit number in the binary system matches. The jar is only one and its price is equal to 1, the number c is also equal to 1, the control number equals 2. The minimal prime divisor of 2 is 2.

In the second test there are 4 jars with numbers from 0 to 3, and the prices are equal 2, 3, 5 and 7 correspondingly — the first four prime numbers. In all recipes numbers should be two-digit. In the first recipe the second digit always is 0, in the second recipe the second digit always is 1, in the third recipe the first digit must be 0, in the fourth recipe the first digit always is 1. Consequently, the control numbers ​​are as follows: in the first recipe 2 × 5 + 11 = 21 (the minimum prime divisor is 3), in the second recipe 3 × 7 + 13 = 44 (the minimum prime divisor is 2), in the third recipe 2 × 3 + 17 = 23 (the minimum prime divisor is 23) and, finally, in the fourth recipe 5 × 7 + 19 = 54 (the minimum prime divisor is 2).

In the third test, the number should consist of fourteen digits and be recorded in a sixteen-base numeral system. Number 0 (the number of the single bottles) matches, the control number will be equal to 1018 + 1. The minimum prime divisor of this number is equal to 101 and you should print -1.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
string cins() {
  char ch[60];
  scanf("%s", ch);
  string s;
  int n = strlen(ch);
  for (int i = 0; i < n; i++) s += ch[i];
  return s;
}
vector<long long> mods;
vector<vector<long long> > ps;
void init() {
  vector<long long> bef;
  long long mul = 1;
  for (int i = 2; i <= 100; i++) {
    int flg = 1;
    for (int j = 2; j < i; j++)
      if (i % j == 0) flg = 0;
    if (flg) {
      if (mul * i > 1e8)
        mods.push_back(mul), ps.push_back(bef), bef.clear(), mul = 1;
      mul *= i, bef.push_back(i);
    }
  }
  if (mul) mods.push_back(mul), ps.push_back(bef), bef.clear();
}
long long w[10008];
int n;
struct cobain {
  vector<int> dp;
  vector<int> fst;
  int d;
  long long mod;
  inline int ask(char c) {
    if (c == '?') return d;
    if (c >= '0' and c <= '9') return c - '0';
    return c - 'A' + 10;
  }
  inline char ans(int x) {
    if (x == d) return '?';
    if (x < 10) return x + '0';
    return x - 10 + 'A';
  }
  int maxlg;
  inline string tos(int x) {
    string s;
    while (x) {
      s += ans(x % (d + 1));
      x /= d + 1;
    }
    reverse(s.begin(), s.end());
    return s;
  }
  inline string _tos(int x) {
    string s;
    while (x) {
      s += ans(x % (d));
      x /= d;
    }
    reverse(s.begin(), s.end());
    return s;
  }
  inline int toi(string s) {
    int x = 0;
    for (int i = 0; i < s.size(); i++) x = x * (d + 1) + ask(s[i]);
    return x;
  }
  void init(int dd, long long modmod) {
    d = dd, mod = modmod;
    maxlg = 0;
    for (int i = 0; i < n; i++) {
      string s = _tos(i);
      maxlg = max(maxlg, (int)s.size());
    }
    string s;
    for (int i = 0; i < maxlg; i++) s += '?';
    int maxn = toi(s);
    dp.reserve(maxn + 20);
    fst.reserve(maxn + 20);
    for (int i = 0; i < maxn + 5; i++) dp.push_back(1), fst.push_back(-1);
    for (int i = 0; i < n; i++) {
      string s = _tos(i);
      dp[toi(s)] = (w[i] % mod);
    }
    int lst = 1;
    for (int i = 1; i <= maxn; i++) {
      if (lst * (d + 1) <= i) lst *= (d + 1);
      int t = lst;
      int x = i / t;
      assert(x and x <= d);
      if (x == d)
        ;
      else
        t = fst[i - x * t];
      if (t == -1) continue;
      fst[i] = t;
      i -= d * t;
      long long tmp = 1;
      for (int k = 0; k < d; k++) {
        i += k * t;
        tmp *= dp[i];
        tmp %= mod;
        i -= k * t;
      }
      i += d * t;
      dp[i] = tmp % mod;
      continue;
    }
    vector<int> p;
    swap(fst, p);
  }
} nirvana[27][10];
int main() {
  init();
  int start = clock();
  scanf("%d", &n);
  for (int i = 0; i < n; i++) scanf("%lld", &w[i]);
  for (int i = 2; i <= 16; i++)
    for (int j = 0; j < mods.size(); j++) nirvana[i][j].init(i, mods[j]);
  int Q = 1;
  scanf("%d", &Q);
  int cnt = 0;
  while (Q--) {
    int d;
    string s;
    long long c;
    ++cnt;
    scanf("%d", &d);
    s = cins();
    scanf("%lld", &c);
    int flg = 0;
    for (int ci = 0; ci < 5 and !flg; ci++) {
      long long mod = mods[ci];
      vector<long long> all;
      long long ui = 0;
      int ls = 0;
      long long ac = 1;
      while (s.size() > ls and (int) s.size() - ls > nirvana[d][ci].maxlg)
        if (s[ls] == '?' or s[ls] == '0')
          ls++;
        else
          ui = 1000000000, ls = 123324;
      if (ui == 0)
        for (int j = ls; j < s.size(); j++) {
          ui = ui * (d + 1) + nirvana[d][ci].ask(s[j]);
          if (ui >= nirvana[d][ci].dp.size()) break;
        }
      if (ui < nirvana[d][ci].dp.size()) ac = nirvana[d][ci].dp[ui] % mod;
      ac = (ac + c % mod) % mod;
      for (int j = 0; j < ps[ci].size(); j++) {
        long long p = ps[ci][j];
        if (ac % p == 0) {
          flg = 1;
          printf("%lld\n", p);
          break;
        }
      }
    }
    if (!flg) puts("-1");
  }
  return 0;
}