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

public class D {
	public static void main (String[] args) throws java.lang.Exception {
		new Solution();
	}
}
class Solution {
	Scanner scanner;
	public Solution() {
		scanner = new Scanner(System.in);

		while (scanner.hasNext()) {
			run_case();
		}
	}

	private void run_case() {
		scanner.nextLine();
		int[] pubs = strToIntArray(scanner.nextLine());
		int[] time = strToIntArray(scanner.nextLine());

		int min_val = (int)1e9 + 1;
		int max_val = 0;
		List<Num> list = new ArrayList<>();
		TreeMap<Integer, Integer> cnt = new TreeMap<>();
		for (int i=0; i<pubs.length; i++) {
			list.add(new Num(pubs[i], time[i]));
			cnt.putIfAbsent(pubs[i], 0);
			cnt.put(pubs[i], cnt.get(pubs[i]) + 1);
			min_val = Math.min(min_val, pubs[i]);
			// max_val = Math.max(max_val, pubs[i]);
		}
		Collections.sort(list, new ComparatorNum());

		// build map
		TreeMap<Integer, Integer> map = new TreeMap<>();
		int cur = min_val;
		int left = 0;
		for (Integer key = cnt.firstKey(); key != null; key = cnt.higherKey(key)) {
			cur = Math.max(cur, key);
			left += cnt.get(key);
			while (left > 0) {
				map.put(cur++, -1);
				left --;
			}
		}

		long res = 0;
		for (int i=0; i<list.size(); i++) {
			int val = list.get(i).val;


			if (map.containsKey(val)) {
				// System.out.println("put val = " + val + ", " + (val + 1));
				map.remove(val);
			} else {
				int nx = map.higherKey(val);
				map.remove(nx);

				long need = nx - val;
				res += need * list.get(i).time;

				// map.put(t, -1);
			}

			// System.out.println("res = " + res);
		}

		System.out.println(res);
		return;

	}


	private int[] strToIntArray(String str) {
	    String[] vals = str.split("\\s+");
	    int sz = vals.length;
	    int[] res = new int[sz];
	    for (int i=0; i<sz; i++) {
	        res[i] = Integer.parseInt(vals[i]);
	    }
	    return res;
	}
}

class Num {
	public int val, time;
    public Num(int val, int time) {
        this.val = val;
        this.time = time;
    }
}


class ComparatorNum implements Comparator<Num> {
    public int compare(Num a, Num b) {
        if (a.time == b.time) {
            return a.val - b.val;
        } else {
            return b.time - a.time;
        }
    }
}
