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

public class d {
  static boolean debug = false;
  public static void main(String[] args) {
    FS in = new FS(System.in); 
    PrintWriter out = new PrintWriter(System.out);
    
    int n = in.nextInt();
    int[] quantities = new int[n];
    TreeMap<Integer, HashSet<Integer>> quantToInd = new TreeMap<>();
    TreeSet<Integer> quants = new TreeSet<>();
    for(int i=0; i<n; i++) {
      quantities[i] = in.nextInt(); 
      quantToInd.putIfAbsent(quantities[i], new HashSet<Integer>());
      quantToInd.get(quantities[i]).add(i);
      quants.add(quantities[i]);
    }

    int[] price = new int[n]; 
    for(int i=0; i<n; i++) {
      price[i] = in.nextInt();
    }

    // So...
    // I think we'll want to start at the leftmost interval.
    // Then see if it's good to shift over.
    // Problem is when two intervals merge.
    // Possible worst case: 2 2 4 4 6 6 8 8 and so forth, so they merge constantly
    // Oh wait, I keep a running sum of the things I need to drop

    if(debug) {
      TreeSet<Integer> test = new TreeSet<>();
      test.add(5);
      test.add(10);
      System.out.printf("%d %d %d\n", test.ceiling(5), test.ceiling(6), test.ceiling(20));
    }

    long ans = 0;
    long runningChange = 0;
    Integer curQuantity = 0;
    PriorityQueue<Integer> prices = new PriorityQueue<>(Collections.reverseOrder());
    while(true) {
      if(prices.isEmpty()) {
        // Attempt to get the next set
        curQuantity = quants.ceiling(curQuantity);
        if(curQuantity == null) break; //we're done.
        HashSet<Integer> hs = quantToInd.get(curQuantity); 
        for(Integer ind : hs) {
          prices.add(price[ind]);
          runningChange += price[ind];
        }
      }
      // Now we walk and do
      while(!prices.isEmpty()) {
        // Place the most expensive one down.
        int toPlace = prices.poll();
        runningChange -= toPlace; 
        curQuantity++; 
        ans += runningChange;

        // See if there's more to place.
        if(quantToInd.containsKey(curQuantity)) {
          HashSet<Integer> hs = quantToInd.get(curQuantity); 
          for(Integer ind : hs) {
            prices.add(price[ind]);
            runningChange += price[ind];
          }
        }
      }
    }

    out.println(ans);
    out.flush();
    // TreeSet<Integer> prices = new TreeSet<>();
    // for(Map.Entry<Integer, HashSet<Integer>> entry : quantToInd.entrySet()) {
    //   int key = entry.getKey();
    //   HashSet<Integer> inds = entry.getValue();
    //   if(debug) System.out.printf("entry.q = %d\n", entry.getKey());

    //   // Now we'll place them all down.
    //   while(true) {

    //   }
    // }

  }
  static class FS {
    BufferedReader in;
    StringTokenizer token;
    public FS(InputStream stream) {
      in = new BufferedReader(new InputStreamReader(stream));
    }
    public String next() {
      if(token == null || !token.hasMoreElements()) {
        try{
          token = new StringTokenizer(in.readLine());
        } catch (Exception e) {}
        return next();
      }
      return token.nextToken();
    }
    public int nextInt() {
      return Integer.parseInt(next());
    }
  }
}

/* 




*/