You are given two arrays a and b, both of length n. All elements of both arrays are from 0 to n-1.

You can reorder elements of the array b (if you want, you may leave the order of elements as it is). After that, let array c be the array of length n, the i-th element of this array is c_i = (a_i + b_i) \% n, where x \% y is x modulo y.

Your task is to reorder elements of the array b to obtain the lexicographically minimum possible array c.

Array x of length n is lexicographically less than array y of length n, if there exists such i (1 ≤ i ≤ n), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a, b and c.

The second line of the input contains n integers a_1, a_2, ..., a_n (0 ≤ a_i < n), where a_i is the i-th element of a.

The third line of the input contains n integers b_1, b_2, ..., b_n (0 ≤ b_i < n), where b_i is the i-th element of b.

Output

Print the lexicographically minimum possible array c. Recall that your task is to reorder elements of the array b and obtain the lexicographically minimum possible array c, where the i-th element of c is c_i = (a_i + b_i) \% n.

Examples

Input


4
0 1 2 1
3 2 1 1


Output


1 0 0 2 


Input


7
2 5 1 5 3 4 3
2 4 3 5 6 5 1


Output


0 0 0 1 0 2 4 

import java.io.DataInputStream; 
import java.io.FileInputStream; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer; 
import java.math.*;
import java.util.*;
//good question 
public class Main 
{ 
    
    public static void main(String[] args) throws IOException 
    { 
        Scanner sc=new Scanner(System.in); 
		int n=sc.nextInt();
		int a[]=new int[n];
		for( int i=0;i<n;i++)
		{
			a[i]=sc.nextInt();
		}
		SupTreeSet<Integer> set=new SupTreeSet<>();
		for( int i=0;i<n;i++)
		{
			set.add(sc.nextInt());
		}
		for( int i=0;i<n;i++)
		{
			int x=(n-a[i]);
			Integer y=set.ceiling(x);
			//System.out.println(y);
			if(y==null)
				y=set.first();
			set.remove(y);
			System.out.print((a[i]+y)%n+" ");
		}
		
		
		
		
	}
}
 class SupTreeSet<T>
 {
	 private int size;
	 private TreeMap<T,Integer> map;
	 public SupTreeSet()
	 {
		 size=0;
		 map=new TreeMap<>();
	 }
	 public int size()
	 {
		 return size;
	 }
	 public int dsize()
	 {
		 return map.size();
	 }
	 public boolean isEmpty()
	 {
		 return size==0;
	 }
	 public void add(T t)
	 {
		 size++;
		 map.put(t,map.getOrDefault(t,0)+1);
	 }
	 public boolean remove(T t)
	 {
		 if(!map.containsKey(t))
			 return false;
		 size--;
		 int c=map.get(t);
		 if(c==1)
		 {
			 map.remove(t);
		 }
		 else
			 map.put(t,c-1);
		 return true;
	 }
	 public int freq(T t)
	 {
		 return map.getOrDefault(t,0);
	 }
	 public boolean contains(T t)
	 {
		 return map.getOrDefault(t,0)>0;
	 }
	 public T ceiling(T t)
	 {
		return map.ceilingKey(t);
	 }
	    public T floor(T t)
		{
			return map.floorKey(t);
		}
        public T first()
		{
			return map.firstKey();
		}
        public T last()
		{
			return map.lastKey();
		}
 }
 




