Omkar is building a waterslide in his water park, and he needs your help to ensure that he does it as efficiently as possible.

Omkar currently has n supports arranged in a line, the i-th of which has height a_i. Omkar wants to build his waterslide from the right to the left, so his supports must be nondecreasing in height in order to support the waterslide. In 1 operation, Omkar can do the following: take any contiguous subsegment of supports which is nondecreasing by heights and add 1 to each of their heights. 

Help Omkar find the minimum number of operations he needs to perform to make his supports able to support his waterslide!

An array b is a subsegment of an array c if b can be obtained from c by deletion of several (possibly zero or all) elements from the beginning and several (possibly zero or all) elements from the end.

An array b_1, b_2, ..., b_n is called nondecreasing if b_i≤ b_{i+1} for every i from 1 to n-1.

Input

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

The first line of each test case contains an integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of supports Omkar has.

The second line of each test case contains n integers a_{1},a_{2},...,a_{n} (0 ≤ a_{i} ≤ 10^9) — the heights of the supports.

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

Output

For each test case, output a single integer — the minimum number of operations Omkar needs to perform to make his supports able to support his waterslide.

Example

Input


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


Output


3
2
0

Note

The subarray with which Omkar performs the operation is bolded.

In the first test case:

  * First operation:

[5, 3, 2, 5] → [5, 3, 3, 5]

  * Second operation:

[5, 3, 3, 5] → [5, 4, 4, 5]

  * Third operation:

[5, 4, 4, 5] → [5, 5, 5, 5]




In the third test case, the array is already nondecreasing, so Omkar does 0 operations.
import java.util.*;
public class Solutions {
	static int MAX=Integer.MAX_VALUE;
	static int MIN=Integer.MIN_VALUE;
	static Scanner scr=new Scanner(System.in);
	public static void main(String[] args) {
		int t=read();
		while(t-->0) {
			solve();
		}
	}
	static void solve() {
		int n=read();;
		long prev=scr.nextLong();
		long ans=0;
		for(int i=1;i<n;i++) {
			long a=scr.nextLong();
			if(prev>a) {
				ans+=prev-a;
			}
			prev=a;
		}
		println(ans);
	}
	static int findTarget(int a, int b, int c, int d) {
        int[] array = new int[] {a,b,c,d};
        Arrays.sort(array);
        return array[1];
    }
	static ArrayList<Integer>N(){
		return new ArrayList<Integer>();
	}
	static int maxInArray(int a[]) {
		int max=-1;int n=len(a);
		for(int i=0;i<n;i++) {
			max=Math.max(max,a[i]);
		}
		return max;
	}
	static int minInArray(int a[]) {
		int min=MAX;int n=len(a);
		for(int i=0;i<n;i++) {
			min=Math.min(min,a[i]);
		}
		return min;
	}
	static int sumOfArray(int a[]) {
		int sum=0;
		for(int i=0;i<len(a);i++) {
			sum+=a[i];
		}
		return sum;
	}
	static char[] charArray(String s) { 
		return s.toCharArray();
	}
	static int[] sort(int a[]) {
		Arrays.sort(a);
		return a;
	}
	static ArrayList<Integer>sort(ArrayList<Integer>a){
		Collections.sort(a);
		return a;
	}
	static String reverse(String s) {
		String res="";
		for(int i=s.length()-1;i>=0;i--) {
			res+=s.charAt(i);
		}
		return res;
	}static ArrayList<Integer>reverse (ArrayList<Integer>a) {
		ArrayList<Integer>b=new ArrayList<Integer>();
		for(int i=a.size()-1;i>=0;i--) {
			b.add(a.get(i));
		}
		return b;
	}
	static int[] reverse(int a[]) {
		int b[]=new int[a.length];;
		int index=0;
		for(int i=a.length-1;i>=0;i--) {
			b[index]=a[i];
			index++;
		}
		return b;
	}
	static int gcd(int a,int b) {
		if(b==0) {
			return a;
		}
		return gcd(b,a%b);
	}
	static long gcd(long a,long b) {
		if(b==0) {
			return a;
		}
		return gcd(b,a%b);
	}
	static void swap(int a[],int i,int j) {
		int temp=a[i];
		a[i]=a[j];
		a[j]=temp;
	}
	static char[] cha(String s) {
		return s.	toCharArray();
	}
	static int len(String s) {
		return s.length();
	}
	static int len(int a[]) {
		return a.length;
	}
	static int len(long a[]) {
		return a.length;
	}
	static int len(ArrayList<Integer>a) {
		return a.size();
	}
	static long abs(long a) {
		return Math.abs(a);
	}static int abs(int a) {
		return Math.abs(a);
	}
	static long min(long a,long b) {
		return Math.min(a, b);
	}static long max(long a,long b) {
		return Math.max(a, b);
	}
	static void print(int a) {
		System.out.print(a+" ");
	}static void print(long a) {
		System.out.print(a+" ");
	}static void print(String a) {
		System.out.print(a);
	}static void println(int a) {
		System.out.println(a);
	}static void println(long a) {
		System.out.println(a);
	}static void println(String a) {
		System.out.println(a);
	}
	static void println() {
		System.out.println();
	}
	static void println(char []c) {
		for(int i=0;i<c.length;i++) {
			System.out.print(c[i]);
		}
		println();
	}
	static int read() {
		return scr.nextInt();
	}
	static String readS() {
		return scr.next();
	}
	static long readL() {
		return scr.nextLong();
	}
	static int[]readIntArray(int n){
//		int n=read();
		int []a=new int[n];
		for(int i=0;i<n;i++) {
			a[i]=scr.nextInt();
		}
		return a;
	}static long[]readLongArray(int n){
		long []a=new long[n];
		for(int i=0;i<n;i++) {
			a[i]=scr.nextLong();
		}
		return a;
	}
	static void printArray(int a[]) {
		int n=a.length;
		for(int i=0;i<n;i++) {
			print(a[i]);
		}
	}
	static void printList(ArrayList<Integer>a) {
		for(Integer i:a) {
			print(i);
		}
	}
}class Triplet{
	int first;
	int second;
	int third;
	Triplet(int fisrt,int second,int third){
		this.first=fisrt;
		this.second=second;
		this.third=third;
	}
}
class pair{
	int x=0;
	int y=0;
	pair(int first,int second){
		this.x=first;
		this.y=second;
	}
}
	