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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;



public class D{
	
	static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }
	
	static class Pair
	{
		int x;
		int t;
		Pair(int x,int t)
		{
			this.x = x;
			this.t = t;
		}
	}
	
	static class Edge
	{
		int x;
		int y;
		Edge(int x,int y)
		{
			this.x = x;
			this.y = y;
		}
	}
	

	public static long gcd(long a,long b)  
	{  
	    if (a == 0)  
	        return b;  
	    return gcd(b%a, a);  
	}  
	  

	
	
	
	public static long power(long x,long y,long m)  
    { 
        if (y == 0) 
            return 1; 
          
        long p = power(x, y / 2, m) % m; 
        p = (p * p) % m; 
      
        if (y % 2 == 0) 
            return p; 
        else
            return (x * p) % m; 
    }
	
	static class newComp implements Comparator<Pair>
	{ 
 
        public int compare(Pair p, Pair q) 
        { 
            if (p.t < q.t) return 1; 
            else if (p.t > q.t) return -1; 
            else return 0; 
        } 
    } 

	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
        FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        int n = sc.nextInt();
        
        int a[] = new int[n];
        
        Pair pr[] = new Pair[n];
        for(int i = 0; i < n; i++)
        {
        	a[i] = sc.nextInt();
        	pr[i] = new Pair(a[i],i);
        }
        
        
        Arrays.sort(pr,(p1,p2)->(p1.x - p2.x));
        
        
        int t[] = new int[n];
        int t1[] = new int[n];
        for(int i = 0; i < n; i++)
        {
        	t1[i] = sc.nextInt();
        }
        
        for(int i = 0; i < n; i++)
        {
        	a[i] = pr[i].x;
        	
        	t[i] = t1[pr[i].t];
        }
        PriorityQueue<Pair> pq = new PriorityQueue<>(10, new newComp());
        
        int next = -1;
        
        long tt = 0L;
        Pair p;
        for(int i = 0; i < n; i++)
        {
        	
        	pq.add(new Pair(a[i],t[i]));
        	
        	if(i == n-1)
        	{	
        		int j = a[i];
        		while(!pq.isEmpty())
        		{
        			p = pq.poll();
            		
            		tt = tt + (long)(j - p.x)*p.t;
            		
            		j++;
        		}
        		break;
        	}
        	next = a[i+1];
        	
        	if(next == a[i]) continue;
        	
        	else if(next == a[i]+1)
        	{
        		p = pq.poll();
        		
        		tt = tt + (long)(a[i] - p.x)*p.t;
        		
        	}
        	else
        	{	
        		int j = a[i];
        		while(j != next && !pq.isEmpty())
        		{
        			p = pq.poll();
            		
            		tt = tt + (long)(j - p.x)*p.t;
            		
            		j++;
        		}
        	}
        
        }
        
        out.println(tt);
        out.close();
	}

}
