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.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        
        int n = Integer.parseInt(sc.next());
        Pair[] p = new Pair[n];
        for(int i = 0; i < n; i++){
            p[i] = new Pair(Integer.parseInt(sc.next()), 0);
        }
        for(int i = 0; i < n; i++){
            p[i].t = Integer.parseInt(sc.next());
        }
        
        Arrays.sort(p);
        PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
        long time = 0;
        long ans = 0;
        int x = p[0].a;
        pq.add(p[0].t);
        time += p[0].t;
        int index = 0;
        while(true){
            if(index < n-1 && pq.isEmpty()){
                index++;
                pq.add(p[index].t);
                time += p[index].t;
                x = p[index].a;
            }
            while(index < n-1 && p[index+1].a == x){
                index++;
                pq.add(p[index].t);
                time += p[index].t;
            }
            if(!pq.isEmpty()){
                int t = pq.poll();
                time -= t;
            }
            if(!pq.isEmpty()){
                ans += time;
                x++;
            }
            if(index == n-1 && pq.isEmpty()){
                break;
            }
        }
        System.out.println(ans);
    }
    
    static class Pair implements Comparable<Pair>{
        int a;
        int t;
        
        public Pair(int a, int t) {
            this.a = a;
            this.t = t;
        }
        
        @Override
        public int compareTo(Pair p) {
            return this.a - p.a;
        }
    }
}