You have n gifts and you want to give all of them to children. Of course, you don't want to offend anyone, so all gifts should be equal between each other. The i-th gift consists of a_i candies and b_i oranges.

During one move, you can choose some gift 1 ≤ i ≤ n and do one of the following operations:

  * eat exactly one candy from this gift (decrease a_i by one); 
  * eat exactly one orange from this gift (decrease b_i by one); 
  * eat exactly one candy and exactly one orange from this gift (decrease both a_i and b_i by one). 



Of course, you can not eat a candy or orange if it's not present in the gift (so neither a_i nor b_i can become less than zero).

As said above, all gifts should be equal. This means that after some sequence of moves the following two conditions should be satisfied: a_1 = a_2 = ... = a_n and b_1 = b_2 = ... = b_n (and a_i equals b_i is not necessary).

Your task is to find the minimum number of moves required to equalize all the given gifts.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.

The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the number of gifts. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the number of candies in the i-th gift. The third line of the test case contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^9), where b_i is the number of oranges in the i-th gift.

Output

For each test case, print one integer: the minimum number of moves required to equalize all the given gifts.

Example

Input


5
3
3 5 6
3 2 3
5
1 2 3 4 5
5 4 3 2 1
3
1 1 1
2 2 2
6
1 1000000000 1000000000 1000000000 1000000000 1000000000
1 1 1 1 1 1
3
10 12 8
7 5 4


Output


6
16
0
4999999995
7

Note

In the first test case of the example, we can perform the following sequence of moves:

  * choose the first gift and eat one orange from it, so a = [3, 5, 6] and b = [2, 2, 3]; 
  * choose the second gift and eat one candy from it, so a = [3, 4, 6] and b = [2, 2, 3]; 
  * choose the second gift and eat one candy from it, so a = [3, 3, 6] and b = [2, 2, 3]; 
  * choose the third gift and eat one candy and one orange from it, so a = [3, 3, 5] and b = [2, 2, 2]; 
  * choose the third gift and eat one candy from it, so a = [3, 3, 4] and b = [2, 2, 2]; 
  * choose the third gift and eat one candy from it, so a = [3, 3, 3] and b = [2, 2, 2]. 
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeSet;
import java.util.Vector;
import java.util.concurrent.ThreadLocalRandom;
public class CodeForces {
	
	 static class Range{
		
		String s;
		public Range(String s){
			this.s = s;
		}
		
		
		@Override
		public String toString() {
			return s;
		}
	}

	static class RangeComparator implements Comparator<Range>{

		public int compare(Range o1, Range o2) {
			String[] v1 = o1.s.split("#");
			String[] v2 = o2.s.split("#");
			int val1 = Integer.parseInt(v1[1])- Integer.parseInt(v1[0]);
			int val2 = Integer.parseInt(v2[1])- Integer.parseInt(v2[0]);
			if(val1>val2){
				return -1;
			}else if(val2>val1){
				return 1;
			}
			return o1.s.compareTo(o2.s);
		}
		
	}

	public static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static int[] getIntArray(BufferedReader br) throws IOException {
		String line = br.readLine();
		String[] values = line.split(" ");
		int[] arr = new int[values.length];
		for (int i = 0; i < values.length; i++) {
			arr[i] = Integer.parseInt(values[i]);
		}
		return arr;
	}
	
	public static long[] getLongArray(BufferedReader br) throws IOException {
		String line = br.readLine();
		String[] values = line.split(" ");
		long[] arr = new long[values.length];
		for (int i = 0; i < values.length; i++) {
			arr[i] = Long.parseLong(values[i]);
		}
		return arr;
	}
	
	public static Set<Integer> getFactors(int n){
		Set<Integer> set = new HashSet<>();
		for(int i=2;i<=Math.sqrt(n);i++){
			if(n%i==0){
				set.add(i);
				set.add(n/i);
			}
		}
		return set;
	}
	
	public static int[] decode(String s){
		String[] v = s.split("#");
		int[] arr = new int[2];
		arr[0] = Integer.parseInt(v[0]);
		arr[1] = Integer.parseInt(v[1]);
		return arr;
	}
	
	public static String encode(int a,int b){
		return a+"#"+b;
	}
	
	public static long lcm(long a,long b){
		BigInteger bigGCD = BigInteger.valueOf(a).gcd(BigInteger.valueOf(b));
		long val = bigGCD.longValue();
		long prod = a *b;
		return prod/val;
	}
	
	public static Set<Integer> getPrimes(){
		Set<Integer> primes = new HashSet<>();
		for(int i=2;i<20000;i++){
			int fac=0;
			for(int j=1;j<=Math.sqrt(i);j++){
				if(i%j==0){
					fac+=2;
				}
			}
			
			if(fac==2){
				primes.add(i);
			}
		}
		
		
		System.out.println(primes.size());
		
		return primes;
	}
	

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		Scanner sc = new Scanner(System.in);	
		String line = br.readLine();
		int t = Integer.parseInt(line);
		
		while (t-- > 0) {
			line = br.readLine();
			int n = Integer.parseInt(line);
			long[] a = getLongArray(br);
			long[] b = getLongArray(br);
			
			long min_a = Long.MAX_VALUE;
			long min_b = Long.MAX_VALUE;
			
			for(int i=0;i<a.length;i++){
				if(a[i]<min_a){
					min_a = a[i];
				}
				if(b[i]<min_b){
					min_b = b[i];
				}
			}
			
			long c=0;
			
			for(int i=0;i<a.length;i++){
				if(a[i]==min_a ){
					if(b[i]!=min_b){
						c+=b[i]-min_b;
					}
				}else if(b[i]==min_b){
					if(a[i]!=min_a){
						c+=a[i]-min_a;
					}
				}else{
					long diff_a = a[i] - min_a;
					long diff_b = b[i] - min_b;
					
					if(diff_a<=diff_b){
						c+=diff_b;
					}else{
						c+=diff_a;
					}
				}
			}
			
			System.out.println(c);
			
			
		}
		
	}

}
 