Problem: Problem

Aizu decided to play a game using a prime number $ P $, a set of natural numbers $ G $, and a natural number $ A $.

First, Aizu writes $ 1 $ on the paper at hand. After that, perform the following series of operations any number of times.

* Select one element from $ G $. Let this be $ g $.
* Write a new product of the number written on the paper at hand and $ g $ on the paper.
* Erase the number originally written on the paper.



If $ A $ is equal to the number written on the paper at hand divided by $ P $, Aizu wins, otherwise he loses. Determine if Aizu can win when $ P $, $ G $, and $ A $ are given.

Constraints

The input satisfies the following conditions.

* All inputs are integers.
* $ 2 \ le P \ le 2 ^ {31} -1 $
* $ 1 \ le T, | G | \ le 10 ^ 5 $
* $ 1 \ le G_i, A \ le P-1 $
* $ G_i \ ne G_j, $ if $ i \ ne j $
* The sum of $ | G | $ in all test cases does not exceed $ 10 ^ 5 $.

Input

The input is given in the following format.


$ P $ $ T $
$ Test_1 $
$ \ vdots $
$ Test_ {T} $


The input consists of multiple test cases. First, the $ 1 $ line is given the prime number $ P $ and the number of test cases $ T $. $ P $ is common to all test cases. Each test case is given in the following $ T $ line.

Each test case is given as follows.


$ | G | $ $ G_1 $ $ \ dots $ $ G_ {| G |} $ $ A $


In each test case, the number of elements of $ G $, each element of $ G $, and $ A $ are given in order, separated by a space.

Output

For each test case, if Aizu can win, $ 1 $ will be output on one line, otherwise $ 0 $ will be output on one line.

Examples

Input

7 3
1 1 2
1 2 1
3 1 2 4 5


Output

0
1
0


Input

1000000007 8
3 2 9 7 5
3 2 9 5 1000001
3 39 1002 65537 12
2 1000000006 518012930 793649232
10 459268180 313723762 835892239 612038995 90424474 366392946 38051435 854115735 5132833 320534710 421820264
1 1 1
1 1 1000000006
1 1000000006 1


Output

0
1
1
1
0
1
0
1

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<pair<long long, long long> > prime_factorize(long long n) {
    vector<pair<long long, long long> > res;
    for (long long p = 2; p * p <= n; ++p) {
        if (n % p != 0) continue;
        int num = 0;
        while (n % p == 0) { ++num; n /= p; }
        res.push_back(make_pair(p, num));
    }
    if (n != 1) res.push_back(make_pair(n, 1));
    return res;
}

long long modpow(long long a, long long n, long long mod) {
    long long res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

int calc_order(long long a, long long P, const vector<pair<long long, long long> > &pf) {
    int res = P - 1;
    for (auto pa : pf) {
        int p = pa.first;
        while (res % p == 0 && modpow(a, res/p, P) == 1) res /= p;
    }
    return res;
}

int GCD(int a, int b) {
    return b ? GCD(b, a % b) : a;
}

int main() {
    int P, T; scanf("%d %d", &P, &T);
    auto pf = prime_factorize(P-1);

    for (int CASE = 0; CASE < T; ++CASE) {
        int N; scanf("%d", &N);
        int gcd = P-1;
        for (int i = 0; i < N; ++i) {
            int G; scanf("%d", &G);
            gcd = GCD(gcd, (P-1)/calc_order(G, P, pf));
        }
        int A; scanf("%d", &A);
        int ga = (P-1)/calc_order(A, P, pf);
        if (ga % gcd == 0) cout << 1 << endl;
        else cout << 0 << endl;
    }
}