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]. 
/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{   
	public static void main (String[] args) throws java.lang.Exception
	{  FastReader in = new FastReader(System.in);
        StringBuilder sb = new StringBuilder();
        int t=1;
        t=in.nextInt();
        while(t>0){
            --t;
         int n=in.nextInt();
         int a[]=new int[n];
         int b[]=new int[n];
         int amin=Integer.MAX_VALUE;
         int bmin=Integer.MAX_VALUE;
         for(int i=0;i<n;i++)
         {
             a[i]=in.nextInt();
             amin=Math.min(amin,a[i]);
         }
         for(int i=0;i<n;i++)
         {
             b[i]=in.nextInt();
             bmin=Math.min(bmin,b[i]);
         }
         Long ans=0L;
         for(int i=0;i<n;i++){
             ans+=Math.max((a[i]-amin),(b[i]-bmin));
         }
         sb.append(ans+"\n");  
        }
	    System.out.print(sb);
	}
	
    static int upper_bound(int arr[],int x){
	    int a=Arrays.binarySearch(arr,x);
	    if(a<0){
	        a*=(-1);
	    
	        return a-1; 
	    }
	    else{
	        
	        while(a<arr.length && arr[a]==x)
	           ++a;
	           return a;
	    }
	}
	static long gcd(long a ,long b)
	{
    if(a==0)
    return b;
    else return gcd(b%a,a);
    }
    
//------making a Fendwick tree ---//
	// creating a fendwick tree
	static long ftree[];
	static void buildFendwicktree(int arr[],int n)
	{
		ftree=new long[n+1];
		for(int i=0;i<n;i++)
			upftree(arr[i],i,n);
	}
	static void upftree(int value,int n,int i)
	{
		int index=i+1;
		while(index<=n)
		{
		  ftree[index]+=value;
		  index+=(index&(-index));  // adding last bit to the index 
		}
	}
	static long getSum(int index)
	{
		long sum=0;
		index+=1;
		while(index>0)
		{
			sum+=ftree[index];
			index-=(index&(-index)); // fliping last index of the tree; 
		}
		return sum;
	}
//------Fendwick tree ends ---------//
}


class sgmtree{
    int arr[];
    sgmtree(int input[],int n){
        arr=new int[100001];
        buildtree(input,1,0,n-1);
    }
    void buildtree(int input[],int si,int ss,int se){
        if(ss==se){
         arr[si]=input[ss];
         return;
        }
         int mid=(ss+se)/2;
         buildtree(input,2*si,ss,mid);
         buildtree(input,2*si+1,mid+1,se);
         arr[si]=Math.min(arr[2*si],arr[2*si+1]);
         
    }
    int query(int si,int ss,int se,int qs,int qe){
        if(qs>se  || qe<ss)
         return Integer.MAX_VALUE;
        
        if(ss>=qs && qe>=se)
        return arr[si];
        
        int mid=(ss+se)/2;
        int l=query(2*si,ss,mid,qs,qe);
        int r=query(2*si+1,mid+1,se,qs,qe);
        return Math.min(l,r);
    }
    void update(int input[],int index,int value){
        input[index]=value;
        updateutils(input,1,0,input.length-1,index);
    }
    void updateutils(int input[],int si,int ss,int se,int qi){
        if(ss==se){
            arr[si]=input[ss];
            return;
        }
        int mid=(ss+se)/2;
        if(qi<=mid)
        updateutils(input,2*si,ss,mid,qi);
        else
        updateutils(input,2*si+1,mid+1,se,qi);
        arr[si]=Math.min(arr[2*si],arr[2*si+1]);
    }
    
}
	
	/* This is for sorting first accorting to gain[1] if gain[1] is same the gain[0]
Arrays.sort(gain, (long[] l1, long[] l2) -> {
	        if(l1[1] != l2[1])return Long.compare(l2[1], l1[1]);//Sorting in non-increasing order of gain
	        return Long.compare(l1[0], l2[0]);//Choosing smallest bit among all bits having same gain
	    });
*/

class pair{
    int x,y;
    pair(int x,int y){
        this.x=x;
        this.y=y;
    }
}	
class CompareValue { 
  
    static void compare(pair arr[], int n) 
    { 
        Arrays.sort(arr, new Comparator<pair>() { 
        public int compare(pair p1, pair p2) 
            { 
                return p1.y - p2.y; 
            } 
        }); 
    } 
}
class CompareKey{
    static void compare(pair arr[],int n){
        Arrays.sort(arr,new Comparator<pair>(){
            public int compare(pair p1,pair p2)
            {
                return p2.x-p1.x;
            }
        });
    }
}
class FastReader {

    byte[] buf = new byte[2048];
    int index, total;
    InputStream in;

    FastReader(InputStream is) {
        in = is;
    }

    int scan() throws IOException {
        if (index >= total) {
            index = 0;
            total = in.read(buf);
            if (total <= 0) {
                return -1;
            }
        }
        return buf[index++];
    }

    String next() throws IOException {
        int c;
        for (c = scan(); c <= 32; c = scan()) ;
        StringBuilder sb = new StringBuilder();
        for (; c > 32; c = scan()) {
            sb.append((char) c);
        }
        return sb.toString();
    }

    String nextLine() throws IOException {
        int c;
        for (c = scan(); c <= 32; c = scan()) ;
        StringBuilder sb = new StringBuilder();
        for (; c != 10 && c != 13; c = scan()) {
            sb.append((char) c);
        }
        return sb.toString();
    }

    char nextChar() throws IOException {
        int c;
        for (c = scan(); c <= 32; c = scan()) ;
        return (char) c;
    }

    int nextInt() throws IOException {
        int c, val = 0;
        for (c = scan(); c <= 32; c = scan()) ;
        boolean neg = c == '-';
        if (c == '-' || c == '+') {
            c = scan();
        }
        for (; c >= '0' && c <= '9'; c = scan()) {
            val = (val << 3) + (val << 1) + (c & 15);
        }
        return neg ? -val : val;
    }

    long nextLong() throws IOException {
        int c;
        long val = 0;
        for (c = scan(); c <= 32; c = scan()) ;
        boolean neg = c == '-';
        if (c == '-' || c == '+') {
            c = scan();
        }
        for (; c >= '0' && c <= '9'; c = scan()) {
            val = (val << 3) + (val << 1) + (c & 15);
        }
        return neg ? -val : val;
    }
}	