B. Deja Vu - 技术栈

time limit per test

2 seconds

memory limit per test

256 megabytes

You are given an array a of length n, consisting of positive integers, and an array x of length q, also consisting of positive integers.

There are q modification. On the i-th modification (1≤i≤q), for each j (1≤j≤n), such that aj is divisible by 2xi, you add 2xi−1 to aj. Note that xi (1≤xi≤30) is a positive integer not exceeding 30.

After all modification queries, you need to output the final array.

Input

The first line contains a single integer t (1≤t≤104) --- the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers n and q (1≤n,q≤105) ---the length of the array a and the number of queries respectively.

The second line of each test case contains n integers a1,a2,a3,...,an --- the elements of the array a (1≤ai≤109).

The third line of each test case contains q integers x1,x2,x3,...,xq --- the elements of the array x (1≤xi≤30), which are the modification queries.

It is guaranteed that the sum of n and the sum of q across all test cases does not exceed 2⋅105.

Output

For each test case, output the array after all of the modification queries.

Example

Input

Copy

复制代码

5 3

1 2 3 4 4

2 3 4

7 3

7 8 12 36 48 6 3

10 4 2

5 4

2 2 2 2 2

1 1 1 1

5 5

1 2 4 8 16

5 2 3 4 1

Output

Copy

复制代码

1 2 3 6 6 
7 10 14 38 58 6 3 
3 3 3 3 3 
1 3 7 11 19

Note

In the first test case, the first query will add 2 to the integers in positions 4 and 5. After this addition, the array would be $1,2,3,6,6$ . Other operations will not modify the array.

In the second test case, the first modification query does not change the array. The second modification query will add 8 to the integer in position 5, so that the array would look like this: $7,8,12,36,56,6,3$ . The third modification query will add 2 to the integers in positions 2,3, 4 and 5. The array would then look like this: $7,10,14,38,58,6,3$ .

解题说明：此题是一道模拟题，给定一个数组 arr 和一组指数 t，按照从小到大的顺序，对数组中能被 2^t 整除的元素，加上 2^(t-1)。每个指数最多使用一次，且一旦使用到最小值就停止。对每个指数 t[j]，检查数组元素 arr[k] 是否能被 2^t[j] 整除，如果能整除，则加上 2^(t[j]-1)。

cpp 复制代码

#include<stdio.h>
#include<math.h>
int main() 
{
    int test = 0;
    scanf("%d", &test);
    for (int i = 0; i < test; i++)
    {
        int n = 0, x = 0;
        scanf("%d", &n);
        scanf("%d", &x);
        int arr[n];
        int t[x];
        for (int j = 0; j < n; j++) 
        {
            scanf("%d", &arr[j]);
        }
        int min = 0;
        int c = 0;
        for (int j = 0; j < x; j++) 
        {
            scanf("%d", &t[j]);
            if (j == 0) 
            {
                min = t[j];
            }
            if (min > t[j])
            {
                min = t[j];
                c = j;
            }
        }
        int num = t[0];
        for (int j = 0; j < c + 1; j++) 
        {
            if (num >= t[j]) 
            {
                for (int k = 0; k < n; k++) 
                {
                    if (arr[k] % (int)pow(2, t[j]) == 0) 
                    {
                        arr[k] = arr[k] + (int)pow(2, t[j] - 1);
                    }
                }
                if (min == t[j])
                {
                    break;
                }
                num = t[j];
            }
        }
        for (int j = 0; j < n; j++)
        {
            printf("%d ", arr[j]);
        }
        printf("\n");
    }
    return 0;
}