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

public class Main {

	static class PairComparator implements Comparator<Pair> {
		@Override
		public int compare(Pair x, Pair y) {
			if (x.val < y.val)
				return -1;
			if (x.val > y.val)
				return 1;
			if (x.val == y.val) {
				if (x.ind < y.ind)
					return -1;
				if (x.ind > y.ind)
					return 1;
			}
			return 0;
		}
	}

	static class Pair {
		int ind, val;

		Pair(int i, int v) {
			ind = i;
			val = v;
		}
	}

	static int[] vis;

	static long sum=0;
	static boolean dfs(int curr, List<Integer >[] tree, int minV, int[] p){
		if (p[curr]==-1){
			int minCurr = Integer.MAX_VALUE;
			for (int i=0;i<tree[curr].size();i++){
				minCurr = Math.min(minCurr, p[tree[curr].get(i)]);	
			}
			p[curr] = minCurr;
		}
		if (p[curr]<minV)return false;
		if (p[curr]!=Integer.MAX_VALUE)sum+=p[curr] - minV;
		for (int i=0;i<tree[curr].size();i++){

			if (!dfs(tree[curr].get(i), tree, p[curr]==-1?minV:p[curr], p)){
				return false;
			}	
		}
		return true;

	}

	static void func() throws Exception {
		int n = sc.nextInt();
		int a[] = sc.intArr(n);
		TreeMap<Integer, Integer > tm = new TreeMap<>();
		for (int i=0;i<n;i++){
			int v= sc.nextInt();
			tm.put(v, tm.getOrDefault(v, 0)+1);
		}
		for (int i=0;i<n;i++){
			int need = n-a[i];
			int r;
			if (tm.higherKey(need-1)!=null)r = tm.higherKey(need-1);
			else r = tm.higherKey(-1);
			tm.put(r, tm.get(r)-1);
			if (tm.get(r)==0)tm.remove(r);
			r = (r + a[i])%n;
			pw.print(r + " ");
		}


		
		
	}

	/*
	 
	 * */
	static PrintWriter pw;
	static MScanner sc;

	public static void main(String[] args) throws Exception {

		pw = new PrintWriter(System.out);
		sc = new MScanner(System.in);

		int tests = 1;
	//	tests =sc.nextInt(); //comment this line
		while (tests-- > 0) {
			func();
			pw.flush();
		}

	}

	static class MScanner {
		StringTokenizer st;
		BufferedReader br;

		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int[] intArr(int n) throws IOException {
			int[] in = new int[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			return in;
		}

		public long[] longArr(int n) throws IOException {
			long[] in = new long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			return in;
		}

		public int[] intSortedArr(int n) throws IOException {
			int[] in = new int[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			shuffle(in);
			Arrays.sort(in);
			return in;
		}

		public long[] longSortedArr(int n) throws IOException {
			long[] in = new long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			shuffle(in);
			Arrays.sort(in);
			return in;
		}

		public Integer[] IntegerArr(int n) throws IOException {
			Integer[] in = new Integer[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			return in;
		}

		public Long[] LongArr(int n) throws IOException {
			Long[] in = new Long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			return in;
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}

	static void shuffle(int[] in) {
		for (int i = 0; i < in.length; i++) {
			int idx = (int) (Math.random() * (i + 1));
			int tmp = in[i];
			in[i] = in[idx];
			in[idx] = tmp;
		}
	}

	static void shuffle(long[] in) {
		for (int i = 0; i < in.length; i++) {
			int idx = (int) (Math.random() * (i + 1));
			long tmp = in[i];
			in[i] = in[idx];
			in[idx] = tmp;
		}
	}
}
