Problem: Let us call two integers x and y adjacent if (lcm(x, y))/(gcd(x, y)) is a perfect square. For example, 3 and 12 are adjacent, but 6 and 9 are not.

Here gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y, and lcm(x, y) denotes the [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple) of integers x and y.

You are given an array a of length n. Each second the following happens: each element a_i of the array is replaced by the product of all elements of the array (including itself), that are adjacent to the current value. 

Let d_i be the number of adjacent elements to a_i (including a_i itself). The beauty of the array is defined as max_{1 ≤ i ≤ n} d_i. 

You are given q queries: each query is described by an integer w, and you have to output the beauty of the array after w seconds.

Input

The first input line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.

The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the length of the array.

The following line contains n integers a_1, …, a_n (1 ≤ a_i ≤ 10^6) — array elements. 

The next line contain a single integer q (1 ≤ q ≤ 3 ⋅ 10^5) — the number of queries.

The following q lines contain a single integer w each (0 ≤ w ≤ 10^{18}) — the queries themselves.

It is guaranteed that the sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values q over all test cases does not exceed 3 ⋅ 10^5

Output

For each query output a single integer — the beauty of the array at the corresponding moment.

Example

Input


2
4
6 8 4 2
1
0
6
12 3 20 5 80 1
1
1


Output


2
3

Note

In the first test case, the initial array contains elements [6, 8, 4, 2]. Element a_4=2 in this array is adjacent to a_4=2 (since (lcm(2, 2))/(gcd(2, 2))=2/2=1=1^2) and a_2=8 (since (lcm(8,2))/(gcd(8, 2))=8/2=4=2^2). Hence, d_4=2, and this is the maximal possible value d_i in this array.

In the second test case, the initial array contains elements [12, 3, 20, 5, 80, 1]. The elements adjacent to 12 are \{12, 3\}, the elements adjacent to 3 are \{12, 3\}, the elements adjacent to 20 are \{20, 5, 80\}, the elements adjacent to 5 are \{20, 5, 80\}, the elements adjacent to 80 are \{20, 5, 80\}, the elements adjacent to 1 are \{1\}. After one second, the array is transformed into [36, 36, 8000, 8000, 8000, 1].

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.lang.*;
public class C {

   static int MAXN=1000003;

   static int smallestFactor[]= new int[MAXN];
   
   static void findSmallestFactor()
   {
      for(int i=0;i<MAXN;i++)
      smallestFactor[i]=i;

      for(int i=2;i*i<MAXN;i++)
      {
         if(smallestFactor[i]==i)
         {
            for(int j=2*i ; j<MAXN;j+=i)
            {
               if(i<smallestFactor[j]) // smallestFactor[j]==j
               smallestFactor[j] = i;
            }

         }
      }

   }

   static void findFactors(int x , HashMap<Long,Integer> map0)
   {
      HashSet<Integer> set= new HashSet<Integer>();
      while(x!=1)
      {
         if(set.contains(smallestFactor[x]))
         set.remove(smallestFactor[x]);
         else
         set.add(smallestFactor[x]);

         x/=smallestFactor[x];
      }

      long res=1;

      for( int i : set )
      {
            res*=i;
      }

      map0.put(res,map0.containsKey(res)? map0.get(res)+1 : 1 );
   }


   public static void main(String[] args) {

      PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);
      int t = sc.nextInt();
      
      // HashMap<Long,Integer> map0 = new HashMap<Long,Integer>();
      // HashMap<Long,Integer> map1 = new HashMap<Long,Integer>();
      findSmallestFactor();
		while(t-->0){
         
      HashMap<Long,Integer> map0 = new HashMap<Long,Integer>();
         int n = sc.nextInt();
			for(int i=0;i<n;i++)
         {
            int in=sc.nextInt();
            // count++;
            findFactors(in,map0);
            // System.out.print(smallestFactor[in] + " ");
         }   
// System.out.print("\n " + count);
      int max0=0,max1=0;

      // map1.put((long)1,0);

      int count1 = 0;

      if(map0.containsKey((long)1)) { count1= map0.get((long)1); map0.remove((long)1);}

      // map1.put((long)1,map0.get((long)1));

      max0=max1=count1;

      // map0.remove((long)1);
      for( Map.Entry<Long, Integer> a : map0.entrySet()){

         // issue is with value of map0.get(1)
         // System.out.print("\n" + a.getKey() + " " + a.getValue());

         max0=Math.max(a.getValue(),max0);
         if(a.getValue() % 2 == 0){
            // map1.put((long)1,map1.get((long)1) +  a.getValue());
            count1+=a.getValue();
            max1=Math.max(count1,max1);
         }
         else
         max1=Math.max(a.getValue(),max1);

      }

      n=sc.nextInt();
      long q=0;
      while(n-->0){
         q=sc.nextLong();
         if(q==0)
         out.write(max0+"\n");
         else
         out.write(max1+"\n");
      }
         
        

    }

    sc.close();
    out.flush();
    out.close();
 }
}