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.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class e {
	public static void main(String[] args) {
		FastScanner in = new FastScanner();
		
		int numElements = in.nextInt();
		int[] a = new int[numElements];
		for(int i=0; i<numElements; i++)
		{
			int num = in.nextInt();
			a[i] = num;
		}
		
		int[] b = new int[numElements];
		int[] bFreq = new int[numElements];
		TreeSet<Num> ts = new TreeSet<Num>();
		for(int i=0; i<numElements; i++)
		{
			int num = in.nextInt();
			b[i] = num;
			bFreq[num]++;
			ts.add(new Num(num, i));
		}
		//System.out.println("bFreq " + Arrays.toString(bFreq));
		
		for(int i=0; i<numElements; i++)
		{
//			int bestInd = chooseBest(i, a, bFreq);
//			bFreq[bestInd]--;
			int base = numElements - a[i];
			Num ceil = ts.ceiling(new Num(base, -1));
			if(ceil == null) ceil = ts.ceiling(new Num(0, -1));
			
			ts.remove(ceil);
			int bestInd = ceil.num;
			int curValue = (a[i] + bestInd)%numElements;
			System.out.print(curValue + " ");
		}
		
	}
	
	// we want lexographically smallest
	public static int chooseBest(int ind, int[] a, int[] bFreq)
	{
		int n = a.length;
		int base = n - a[ind];
		for(int i=0; i<n; i++)
		{
			int cur = (base + i)%n;
//			System.out.printf("ind=%d, a[ind]=%d, base=%d, cur=%d\n", );
			if(bFreq[cur] > 0)
			{
				return cur;
			}
		}
		return -1;
	}
	
	public static class Num implements Comparable<Num>
	{
		public int num, id;
		public Num(int x, int ID)
		{
			num = x; id = ID;
		}
		
		public int compareTo(Num o)
		{
			if(num != o.num) return Integer.compare(num, o.num);
			return Integer.compare(id, o.id);
		}
	}
	
	
	
	public static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}
	}
	
}

/*

4
0 1 2 1
3 2 1 1

1 0 0 2


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

0 0 0 1 0 2 4


Another greedy, I believe

*/