Problem: Being stuck at home, Ray became extremely bored. To pass time, he asks Lord Omkar to use his time bending power: Infinity Clock! However, Lord Omkar will only listen to mortals who can solve the following problem:

You are given an array a of n integers. You are also given an integer k. Lord Omkar wants you to do k operations with this array.

Define one operation as the following: 

  1. Set d to be the maximum value of your array. 
  2. For every i from 1 to n, replace a_{i} with d-a_{i}. 



The goal is to predict the contents in the array after k operations. Please help Ray determine what the final sequence will look like!

Input

Each test contains multiple test cases. The first line contains the number of cases t (1 ≤ t ≤ 100). Description of the test cases follows.

The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 10^{18}) – the length of your array and the number of operations to perform.

The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (-10^9 ≤ a_{i} ≤ 10^9) – the initial contents of your array.

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.

Output

For each case, print the final version of array a after k operations described above.

Example

Input


3
2 1
-199 192
5 19
5 -1 4 2 0
1 2
69


Output


391 0
0 6 1 3 5
0

Note

In the first test case the array changes as follows:

  * Initially, the array is [-199, 192]. d = 192.

  * After the operation, the array becomes [d-(-199), d-192] = [391, 0].

Solution (in JAVA):

Solution:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.PriorityQueue;

public class Main {


    static BufferedReader br;

    public static void main(String[] args) throws Exception {
        // write your code here
        br = new BufferedReader(new InputStreamReader(System.in));

        int t = (int) in();
        while (t-- > 0) {

            long data[] = data(2);
            int n = (int)data[0];
            long k = data[1];
            data = data(n);
            PriorityQueue<holder> priorityQueue = new PriorityQueue<>(n,new so());
            for(int i =0;i<n;i++){
                priorityQueue.add(new holder(data[i],i));
            }
            int i =0;
            if(k%2==0){
                k=2;
            }else{
                k=1;
            }
            while (i<k){

                long max= priorityQueue.peek().d1;

                PriorityQueue<holder>one = new PriorityQueue<>(n,new so());
                while (!priorityQueue.isEmpty()){
                    holder holder = priorityQueue.peek();
                    long v= holder.d1;
                    int index = holder.index;
                    priorityQueue.poll();

                    one.add(new holder(max-v,index));
                }
                i++;
                priorityQueue.clear();;
                priorityQueue=one;
            }
            long ans[] = new long[n];
            for(int j=0;j<n;j++){
                holder holder = priorityQueue.poll();
                long v= holder.d1;
                int index = holder.index;
                ans[index]= v;

            }
            StringBuilder sb = new StringBuilder();
            for(int j=0;j<n;j++){
                sb.append(ans[j]+" ");

            }
            System.out.println(sb.toString());

        }
    }


    static long[] data(long n) throws Exception {

        String read[] = sarrin();
        long data[] = new long[(int) n];
        for (int k = 0; k < n; k++)
            data[k] = in(read[k]);
        return data;

    }

    static long[][] data(long n, long m) throws Exception {


        long data[][] = new long[(int) n][(int) m];
        for (int k = 0; k < n; k++) {
            String read[] = sarrin();
            for (int j = 0; j < m; j++)
                data[k][j] = in(read[k]);
        }
        return data;

    }

    static long in() throws Exception {
        return Long.parseLong(br.readLine());


    }

    static long in(String num) throws Exception {
        return Long.parseLong(num);


    }


    static String sin() throws Exception {

        return br.readLine();
    }

    static String[] sarrin() throws Exception {

        return br.readLine().split(" ");

    }

    static String[] regexSplit() throws Exception {
        return br.readLine().split(" ?(?<!\\G)((?<=[^\\p{Punct}])(?=\\p{Punct})|\\b) ?");
    }

    static int integer() throws Exception {
        return Integer.parseInt(br.readLine());
    }


}

class holder{
    long d1;
    int index;

    public holder(long d1, int index) {
        this.d1 = d1;
        this.index = index;
    }
}
class so implements Comparator<holder>{


    @Override
    public int compare(holder holder, holder t1) {
        if(holder.d1<t1.d1){
            return 1;
        }else{
            return -1;
        }
    }
}