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.lang.reflect.Array;
import java.security.acl.LastOwnerException;
import java.util.*;
import java.util.stream.Collectors;


public class Main {

    static Long max = (long) (2 * 10E5);
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    // Arrays.stream(br.readLine().split("\\s+")).map(Integer::parseInt).toArray(Integer[]::new);
    // Arrays.stream(br.readLine().split("\\s+")).map(Long::parseLong).toArray(Long[]::new);
    // Integer.parseInt(br.readLine());
    // Long.parseLong(br.readLine());


    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine());
        Long[] a = Arrays.stream(br.readLine().split("\\s+")).map(Long::parseLong).toArray(Long[]::new);
        Long[] time = Arrays.stream(br.readLine().split("\\s+")).map(Long::parseLong).toArray(Long[]::new);
        SortedMap<Long, ArrayList<Long>> map = new TreeMap<>();
        for (int i = 0; i < a.length; i++) {
            if (!map.containsKey(a[i]))
                map.put(a[i], new ArrayList<>());
            map.get(a[i]).add(time[i]);
        }
        long counter = 0, leftSum = 0;
        long prevValue = -1;
        SortedMap<Long, Long> multiset = new TreeMap<>();
        while (!(multiset.size() == 0 && map.isEmpty())) {
            if (map.size() > 0) {
                long key = map.firstKey();
                if (prevValue + 1 == key || multiset.isEmpty()) {
                    ArrayList<Long> value = map.get(key);
                    if (!(multiset.isEmpty() && value.size() == 1))
                        for (long v : value) {
                            multiset.put(v, multiset.getOrDefault(v, 0L) + 1);
                            leftSum += v;
                        }
                    map.remove(key);
                    prevValue = key;
                } else if (prevValue != -1) {
                    prevValue += 1;
                }
            }

            if (multiset.size() > 0) {
                long mLK = multiset.lastKey();
                multiset.put(mLK, multiset.get(mLK) - 1);
                leftSum -= mLK;
                if (multiset.get(mLK) == 0)
                    multiset.remove(mLK);
                counter += leftSum;
            }
        }
        System.out.println(counter);

    }
}