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.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Problem623D_2 {
	public static void main(String[] args) throws Exception {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter writer = new PrintWriter(System.out);
		int n = Integer.parseInt(reader.readLine());
		StringTokenizer tokenizer = new StringTokenizer(reader.readLine());
		int[] a = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = Integer.parseInt(tokenizer.nextToken());
		}
		StringTokenizer tokenizer2 = new StringTokenizer(reader.readLine());
		long[] t = new long[n];
		for (int i = 0; i < n; i++) {
			t[i] = Long.parseLong(tokenizer2.nextToken());
		}
		long totalTime = 0;
		Integer[] indices = new Integer[n];
		for (int i = 0; i < indices.length; i++) {
			indices[i] = i;
		}
		Comparator<Integer> lol1 = Comparator.comparingInt(i -> a[i]);
		Arrays.sort(indices, lol1);

		long counter = -1;
		PriorityQueue<Long> queue = new PriorityQueue<Long>(Comparator.comparingLong(i -> -i)); // reverse
		long queueSum = 0;

		for (int i = 0; i < indices.length; i++) {
			int index = indices[i];
			// Resolve everything before a[index]
			if (counter != -1) {
				while (!queue.isEmpty() && counter < a[index]) {
					queueSum -= queue.poll();
					totalTime += queueSum;
					counter++;
				}
			}
			// add t[index] to queue
			queue.add(t[index]);
			queueSum += t[index];
			counter = a[index];
		}
		// Resolve everything else in queue
		while (!queue.isEmpty()) {
			queueSum -= queue.poll();
			totalTime += queueSum;
		}

		writer.println(totalTime);
		writer.close();
	}
}
