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.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.AbstractCollection;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.util.Comparator;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int N = in.nextInt();
            int a[] = new int[N], b[] = new int[N];
            for (int i = 0; i < N; i++) {
                a[i] = in.nextInt();
            }
            for (int i = 0; i < N; i++) {
                b[i] = in.nextInt();
            }
            long ans = 0;
            Pair pairs[] = new Pair[N];
            for (int i = 0; i < N; i++) {
                pairs[i] = new Pair(i, a[i], b[i]);
            }
            Arrays.sort(pairs, new Comparator<Pair>() {

                public int compare(Pair o1, Pair o2) {
                    if (o1.num != o2.num) {
                        return Long.compare(o1.num, o2.num);
                    }
                    return Long.compare(o1.cost, o2.cost);
                }
            });

            PriorityQueue<Pair> queue = new PriorityQueue<>(new Comparator<Pair>() {

                public int compare(Pair o1, Pair o2) {
                    if (o1.cost != o2.cost) {
                        return Long.compare(o2.cost, o1.cost);
                    }
                    return o1.index - o2.index;
                }
            });
            long totalInQueue = 0;
            int index = 0;
            long topNum = pairs[index].num;
            queue.add(pairs[index]);
            totalInQueue += pairs[index].cost;
            index++;
            while (!queue.isEmpty()) {
                while (index < N) {
                    if (pairs[index].num > topNum) {
                        break;
                    }
                    queue.add(pairs[index]);
                    totalInQueue += pairs[index].cost;
                    index++;
                }
                Pair p = queue.poll();
                totalInQueue -= p.cost;
                topNum++;
                ans += totalInQueue;
                if (queue.isEmpty() && index < N) {
                    queue.add(pairs[index]);
                    totalInQueue += pairs[index].cost;
                    topNum = pairs[index].num;
                    index++;
                }
            }
            out.printLine(ans);
        }

        class Pair {
            int index;
            long num;
            long cost;

            public Pair(int index, long num, long cost) {
                this.index = index;
                this.num = num;
                this.cost = cost;
            }

        }

    }

    static class InputReader {
        BufferedReader in;
        StringTokenizer tokenizer = null;

        public InputReader(InputStream inputStream) {
            in = new BufferedReader(new InputStreamReader(inputStream));
        }

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

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

    }

    static class OutputWriter {
        PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }
}

