VK news recommendation system daily selects interesting publications of one of n disjoint categories for each user. Each publication belongs to exactly one category. For each category i batch algorithm selects a_i publications.

The latest A/B test suggests that users are reading recommended publications more actively if each category has a different number of publications within daily recommendations. The targeted algorithm can find a single interesting publication of i-th category within t_i seconds. 

What is the minimum total time necessary to add publications to the result of batch algorithm execution, so all categories have a different number of publications? You can't remove publications recommended by the batch algorithm.

Input

The first line of input consists of single integer n — the number of news categories (1 ≤ n ≤ 200 000).

The second line of input consists of n integers a_i — the number of publications of i-th category selected by the batch algorithm (1 ≤ a_i ≤ 10^9).

The third line of input consists of n integers t_i — time it takes for targeted algorithm to find one new publication of category i (1 ≤ t_i ≤ 10^5).

Output

Print one integer — the minimal required time for the targeted algorithm to get rid of categories with the same size.

Examples

Input


5
3 7 9 7 8
5 2 5 7 5


Output


6


Input


5
1 2 3 4 5
1 1 1 1 1


Output


0

Note

In the first example, it is possible to find three publications of the second type, which will take 6 seconds.

In the second example, all news categories contain a different number of publications.
import java.util.*;
import java.io.*;
 
public class Solution{
	long rem = 1000000007L;
	int[] heap;
	int len;
	public Solution(){
		Scanner sc = new Scanner(System.in);
		int tests = 1;
        
        for(int t=1; t<=tests; t++){
			int n = sc.nextInt();
			Pair[] c = new Pair[n];
			
			for(int i=0; i<n; i++){
				c[i] = new Pair(sc.nextInt());
			}
			for(int i=0; i<n; i++){
				c[i].t = sc.nextInt();
			}
			
			heap = new int[n];
			len = 0;
			
			Arrays.sort(c, new Comparator<Pair>(){
				public int compare(Pair p1, Pair p2){
					if(p1.a < p2.a){
						return -1;
					}
					else if(p1.a > p2.a){
						return 1;
					}
					else if(p1.t > p2.t){
						return -1;
					}
					else if(p1.t < p2.t){
						return 1;
					}
					else{
						return 0;
					}
				}
			});
			
			long res = 0L;
			long num = c[0].a;
			long sum = 0L;
			
			for(int i=0; i<n; i++){
				num = c[i].a;
				while(i < n && c[i].a == num){
					heap[len++] = c[i].t;
					sum += c[i].t;
					bottomUp(len);
					i++;
				}
				
				while(len > 0){
					sum -= heap[0];
					heap[0] = heap[len-1];
					len--;
					maxHeapify(1);
					
					res += sum;
					num++;
					while(i < n && c[i].a == num){
						heap[len++] = c[i].t;
						sum += c[i].t;
						bottomUp(len);
						i++;
					}
				}
				i--;
			}
			
			System.out.println(res);
        }
	}
	
	public void maxHeapify(int index){
		if(index > (len/2)){
			return;
		}
		
		int ind = index;
		if(heap[ind-1] < heap[(2*index) - 1]){
			ind = 2*index;
		}
		if((2*index) < len && heap[ind-1] < heap[(2*index)]){
			ind = 2*index+1;
		}
		
		if(ind != index){
			int temp = heap[index-1];
			heap[index-1] = heap[ind-1];
			heap[ind-1] = temp;
			
			maxHeapify(ind);
		}
	}
	
	public void bottomUp(int index){
		while(index > 1){
			int parent = index/2;
			if(heap[parent-1] < heap[index-1]){
				int temp = heap[index-1];
				heap[index-1] = heap[parent-1];
				heap[parent-1] = temp;
				index = parent;
			}
			else{
				break;
			}
		}
	}
	
	public static void main(String[] args){
		new Solution();
	}
}
class Pair{
	public int a;
	public int t;
	
	public Pair(int a){
		this.a = a;
		t = 0;
	}
}