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.util.*;
import java.io.*;
import java.math.BigInteger;

public class counting {
	

	public static void main(String[] args)throws IOException{
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		
		int n = Integer.parseInt(br.readLine());
		
		int a[] = new int [n];
		
		StringTokenizer st1 = new StringTokenizer(br.readLine());
		
		for(int i = 0 ; i < n ; i++)
			a[i] = Integer.parseInt(st1.nextToken());
		
		st1 = new StringTokenizer(br.readLine());
		
		TreeSet<Integer> tr = new TreeSet<>();
		HashMap<Integer, Integer> hm = new HashMap<>();
		
		for(int i = 0 ; i < n ; i++)
		{
			int b = Integer.parseInt(st1.nextToken());
			hm.put(b, hm.getOrDefault(b, 0)+1);
			tr.add(b);
		}
		
		for(int i = 0 ; i < n ; i++)
		{
			if(tr.contains(n-a[i]))
			{
				out.print(0 + " ");
				
				hm.put(n-a[i], hm.get(n-a[i])-1);
				
				if(hm.get(n-a[i]) == 0)
				{
					tr.remove(n-a[i]);
				}
				
			}
			else
			{
				Integer e1 = tr.first();
				Integer e2 = tr.ceiling(n-a[i]);
				
				
			//	System.err.println(e1 + " " + e2);
				
				
				if(e2 == null || (e1 != null &&(a[i]+e1) % n <= (a[i]+e2) % 2))
				{
					out.print((a[i]+e1) % n + " ");
					
					hm.put(e1, hm.get(e1)-1);
					
					if(hm.get(e1) == 0)
					{
						tr.remove(e1);
					}
					
				}
				else
				{
					out.print((a[i]+e2) % n + " ");
					
					hm.put(e2, hm.get(e2)-1);
					
					if(hm.get(e2) == 0)
					{
						tr.remove(e2);
					}
					
				}
				
			}
		}
		
		
		
		
		
		
		
		
		
		out.flush();
		out.close();
		
	}
	
	
}