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.io.*;
import java.util.*;

public class Main {
	static Scanner sc = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) throws Exception {
		int n = sc.nextInt();
		Pair arr[] = new Pair[n];
		for(int i = 0; i < n; i++) {
			arr[i] = new Pair(sc.nextInt(),0);
		}
		
		for(int i = 0; i < n; i++) {
			arr[i].cost = sc.nextInt();
		}
		
		PriorityQueue<Pair> pq = new PriorityQueue<>();
		for(int i = 0; i < n; i++) {
			pq.add(arr[i]);
		}
		
		long ans = 0,cur = 0;
		PriorityQueue<Node> rem = new PriorityQueue<>();
		while(!pq.isEmpty()) {
			while(!rem.isEmpty() && cur < pq.peek().val) {
				long v = rem.peek().val, c = rem.poll().cost;
				ans += c * (cur - v);
				cur++;
			}
			
			cur = pq.peek().val;
			while(!pq.isEmpty() && pq.peek().val == cur) {
				rem.add(new Node(pq.peek().cost,cur));
				pq.poll();
			}
		}
		
		while(!rem.isEmpty()) {
			long v = rem.peek().val, c = rem.poll().cost;
			ans += c * (cur - v);
			cur++;
		}
		
		
		out.println(ans);
		out.close();
	}
	
	static class Pair implements Comparable<Pair>{
		long val,cost;
		public Pair(long val, long cost) {
			this.val = val;
			this.cost = cost;
		}
		
		public int compareTo(Pair o) {
			if(val == o.val) {
				if(cost < o.cost) {
					return -1;
				}
				return 1;
			}
			if(val < o.val) {
				return -1;
			}
			return 1;
		}	
	}
	
	static class Node implements Comparable<Node>{
		long cost,val;
		public Node(long cost, long val) {
			this.cost = cost;
			this.val = val;
		}
		
		public int compareTo(Node o) {
			if(cost < o.cost) {
				return 1;
			}
			return -1;
		}
	}

}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream system) {
		br = new BufferedReader(new InputStreamReader(system));
	}

	public Scanner(String file) throws Exception {
		br = new BufferedReader(new FileReader(file));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public Long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}
