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.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.TreeMap;


public class E implements Runnable
{

	static BufferedReader br = null;
	static PrintWriter pw = null;
	static StringTokenizer stk = new StringTokenizer("");

	public static void main(String[] args)
	{
		try
		{
			//br = new BufferedReader(new FileReader("input.txt"));
			//pw = new PrintWriter("output.txt");
			br = new BufferedReader(new InputStreamReader(System.in));
			pw = new PrintWriter(new OutputStreamWriter(System.out));
			
		} catch (Exception e)
		{
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		(new Thread(new E())).start();
	}

	public void nline()
	{
		try
		{
			stk = new StringTokenizer(br.readLine());
		} catch (IOException e)
		{
			e.printStackTrace();
		}
	}

	public int ni()
	{
		while (!stk.hasMoreTokens())
			nline();
		return Integer.valueOf(stk.nextToken());
	}

	public double nd()
	{
		while (!stk.hasMoreTokens())
			nline();
		return Double.valueOf(stk.nextToken());
	}

	public String nwrd()
	{
		while (!stk.hasMoreTokens())
			nline();
		return stk.nextToken();
	}

	public long nl()
	{
		while (!stk.hasMoreTokens())
			nline();
		return Long.valueOf(stk.nextToken());
	}

	public BigInteger nbi()
	{
		while (!stk.hasMoreTokens())
			nline();
		return new BigInteger(stk.nextToken());
	}

	public char nc()
	{
		while (!stk.hasMoreTokens())
			nline();
		return stk.nextToken().charAt(0);
	}

	public boolean isready()
	{
		try
		{
			return br.ready();
		} catch (IOException e)
		{
			return false;
		}
	}

	String rline()
	{
		try
		{
			return br.readLine();
		} catch (IOException e)
		{
			e.printStackTrace();
		}
		return null;
	}

	public void run()
	{
		solve();
		pw.close();
	}
	public class Hero {
		public long max_health;
		public long regen;
		public Hero(long h, long regen) {
			// TODO Auto-generated constructor stub
			max_health = h;
			this.regen = regen;
		}
	}
	public class Pair implements Comparable<Pair>{
		public int a;
		public int b;
		public Pair left;
		public Pair right;
		public Pair( int a, int b) {
			// TODO Auto-generated constructor stub
			this.a = a;
			this.b = b;
		}
		@Override
		public int compareTo(Pair o) {
			// TODO Auto-generated method stub
			if (a != o.a)
				return (int) ( - a + o.a);
			if (b != o.b)
				return (int) (b - o.b);
			return 0;
		}
		public  String toString() {
			return a + " " + b;
		}
		
	}
	
	private TreeMap<Integer, Integer> map = new TreeMap<>();
	
	
	private void addMap(int i)
	{
		Integer ni = map.get(i);
		
		int cnt = (ni==null)?0:ni ;
		cnt++;
		map.put(i, cnt);
	}
	
	private void decMap(int i)
	{
		Integer ni = map.get(i);
		int cnt = (ni==null)?0:ni ;
		if (cnt <=1 ) { map.remove(i); return;}
		cnt--;
		map.put(i, cnt);
	}
	

	public void solve()
	{
		int n = ni();
		int mas[] = new int[n];
		for(int i=0; i<n;i++)
			mas[i] = ni();
		for(int i =0 ; i< n; i++)
			addMap(ni());
		
		for(int i =0; i<n; i++)
		{
			int v1 = map.firstKey();
			int modv1 = (v1 + mas[i]) %n;
			Integer vi2 = map.ceilingKey(n-mas[i]);

			if	(vi2 == null)
			{
				pw.print(modv1 + " ");
				decMap(v1);
				continue;
			}
			int v2 = vi2;

			int modv2 = (v2 + mas[i]) %n;
		
			if(modv1 < modv2) 
			{
				pw.print(modv1 + " ");
				decMap(v1);
			}
			else
			{
				pw.print(modv2 + " ");
				decMap(v2);
			}
			
		}
		
		
	}

}