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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        int n = in.nextInt();
        int[] a = new int[n];
        for (int i=0;i<n;i++) {
            a[i] = in.nextInt();
        }
        int[] t = new int[n];
        for (int i=0;i<n;i++) {
            t[i] = in.nextInt();
        }
        ArrayList<int[]> list = new ArrayList<int[]>();
        for (int i=0;i<n;i++) {
            int[] add = {a[i], t[i]};
            list.add(add);
        }
        Collections.sort(list, (o1, o2)->Integer.compare(o1[0], o2[0]));

        // TreeSet<Integer> set = new TreeSet<Integer>();
        TreeMap<Integer, Integer> set = new TreeMap<Integer, Integer>();
        long ans = 0L;
        long set_sum = 0L;
        int list_index = 0;
        long pos = 0L;

        // for (int i=0;i<n;i++) {
            // out.println(Arrays.toString(list.get(i)));
        // }

        while (list_index<n || (list_index==n && set.size()>0)) {
            if (set.size()==0 && pos<list.get(list_index)[0]) pos=list.get(list_index)[0];
            while (list_index<n && pos==list.get(list_index)[0]) {
                int pos_list = list.get(list_index)[0];
                int t_list = list.get(list_index)[1];
                pos = pos_list;
                // set.add(t_list);
                if (set.containsKey(t_list)) {
                    set.put(t_list, set.get(t_list)+1);
                } else {
                    set.put(t_list, 1);
                }

                set_sum += t_list;
                list_index++;
                // out.println("t_list: "+t_list);
            }

            if (set.size()>0) {
                // int rem = set.last();
                int rem = set.lastEntry().getKey();
                // set.remove(rem);
                if (set.get(rem)>1) {
                    set.put(rem, set.get(rem)-1);
                } else {
                    set.remove(rem);
                }
                set_sum -= rem;
                ans += set_sum;
                // out.println("set_sum: "+set_sum);
            }
            pos++;
        }
        out.println(ans);
        out.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}
