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.*;
import static java.lang.Math.*;

public class Main implements Runnable {
	FastReader scn;
	PrintWriter out;
	String INPUT = "";

	void solve() {
		int n = scn.nextInt();
		int[] A = scn.nextIntArray(n);
		int[] B = scn.nextIntArray(n);
		TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
		for(int b : B) {
			map.merge(b, 1, Integer::sum);
		}
		
		for(int a : A) {
			int x = n - a;
			int key;
			if(map.ceilingKey(x) != null) {
				key = map.ceilingKey(x);
			} else {
				key = map.firstKey();
			}
			map.merge(key, -1, Integer::sum);
			if(map.get(key) == 0) {
				map.remove(key);
			}
			out.print((a + key) % n + " ");
		}
		out.println();
	}
	
	public class LongHashCounter {
		public long[] keys;
		public int[] allocated;
		private int scale = 1 << 2;
		private int rscale = 1 << 1;
		private int mask = scale - 1;
		public int size = 0;

		public LongHashCounter() {
			allocated = new int[scale];
			Arrays.fill(allocated, NG);
			keys = new long[scale];
		}

		// if value is NG, entry is removed. (e.g. 0)
		private static final int NG = 0;

		public boolean containsKey(long x) {
			int pos = h(x) & mask;
			while (allocated[pos] != NG) {
				if (x == keys[pos])
					return true;
				pos = pos + 1 & mask;
			}
			return false;
		}

		public int get(long x) {
			int pos = h(x) & mask;
			while (allocated[pos] != NG) {
				if (x == keys[pos])
					return allocated[pos];
				pos = pos + 1 & mask;
			}
			return NG;
		}

		public int put(long x, int v) {
			int pos = h(x) & mask;
			while (allocated[pos] != NG) {
				if (x == keys[pos]) {
					int oldval = allocated[pos];
					allocated[pos] = v;
					return oldval;
				}
				pos = pos + 1 & mask;
			}
			if (size == rscale) {
				resizeAndPut(x, v);
			} else {
				keys[pos] = x;
				allocated[pos] = v;
			}
			size++;
			return NG;
		}

		public int inc(long x, int v) {
			int pos = h(x) & mask;
			while (allocated[pos] != NG) {
				if (x == keys[pos]) {
					allocated[pos] += v;
					return allocated[pos];
				}
				pos = pos + 1 & mask;
			}
			if (size == rscale) {
				resizeAndPut(x, v);
			} else {
				keys[pos] = x;
				allocated[pos] = v;
			}
			size++;
			return v;
		}

		public boolean remove(long x) {
			int pos = h(x) & mask;
			while (allocated[pos] != NG) {
				if (x == keys[pos]) {
					size--;
					// take last and fill rmpos
					int last = pos;
					pos = pos + 1 & mask;
					while (allocated[pos] != NG) {
						int lh = h(keys[pos]) & mask;
						// lh <= last < pos
						if (lh <= last && last < pos || pos < lh && lh <= last || last < pos && pos < lh) {
							keys[last] = keys[pos];
							allocated[last] = allocated[pos];
							last = pos;
						}
						pos = pos + 1 & mask;
					}
					keys[last] = 0;
					allocated[last] = NG;

					return true;
				}
				pos = pos + 1 & mask;
			}
			return false;
		}

		private void resizeAndPut(long x, int v) {
			int nscale = scale << 1;
			int nrscale = rscale << 1;
			int nmask = nscale - 1;
			int[] nallocated = new int[nscale];
			Arrays.fill(nallocated, NG);
			long[] nkeys = new long[nscale];
			for (int i = next(0); i < scale; i = next(i + 1)) {
				long y = keys[i];
				int pos = h(y) & nmask;
				while (nallocated[pos] != NG)
					pos = pos + 1 & nmask;
				nkeys[pos] = y;
				nallocated[pos] = allocated[i];
			}
			{
				int pos = h(x) & nmask;
				while (nallocated[pos] != NG)
					pos = pos + 1 & nmask;
				nkeys[pos] = x;
				nallocated[pos] = v;
			}
			allocated = nallocated;
			keys = nkeys;
			scale = nscale;
			rscale = nrscale;
			mask = nmask;
		}

		public int next(int itr) {
			while (itr < scale && allocated[itr] == NG)
				itr++;
			return itr;
		}

		private int h(long x) {
			x ^= x >>> 33;
			x *= 0xff51afd7ed558ccdL;
			x ^= x >>> 33;
			x *= 0xc4ceb9fe1a85ec53L;
			x ^= x >>> 33;
			return (int) x;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			for (int i = next(0); i < scale; i = next(i + 1)) {
				sb.append(",");
				sb.append(keys[i] + ":" + allocated[i]);
			}
			return sb.length() == 0 ? "" : sb.substring(1);
		}
	}

	public void run() {
		long time = System.currentTimeMillis();
		boolean oj = System.getProperty("ONLINE_JUDGE") != null;
		out = new PrintWriter(System.out);
		scn = new FastReader(oj);
		solve();
		out.flush();
		if (!oj) {
			System.out.println(Arrays.deepToString(new Object[] { System.currentTimeMillis() - time + " ms" }));
		}
	}

	public static void main(String[] args) {
		new Thread(null, new Main(), "Main", 1 << 26).start();
	}

	class FastReader {
		InputStream is;

		public FastReader(boolean onlineJudge) {
			is = onlineJudge ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		}

		byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		int readByte() {
			if (lenbuf == -1)
				throw new InputMismatchException();
			if (ptrbuf >= lenbuf) {
				ptrbuf = 0;
				try {
					lenbuf = is.read(inbuf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return -1;
			}
			return inbuf[ptrbuf++];
		}

		boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}

		int skip() {
			int b;
			while ((b = readByte()) != -1 && isSpaceChar(b))
				;
			return b;
		}

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

		char nextChar() {
			return (char) skip();
		}

		String next() {
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		String nextLine() {
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while ((!isSpaceChar(b) || b == ' ')) { // when nextLine, (isSpaceChar(b) && b != ' ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		char[] next(int n) {
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while (p < n && !(isSpaceChar(b))) {
				buf[p++] = (char) b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		int nextInt() {
			int num = 0, b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		long nextLong() {
			long num = 0;
			int b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		char[][] nextMatrix(int n, int m) {
			char[][] map = new char[n][];
			for (int i = 0; i < n; i++)
				map[i] = next(m);
			return map;
		}

		int[] nextIntArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		long[] nextLongArray(int n) {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}

		int[][] next2DInt(int n, int m) {
			int[][] arr = new int[n][];
			for (int i = 0; i < n; i++) {
				arr[i] = nextIntArray(m);
			}
			return arr;
		}

		long[][] next2DLong(int n, int m) {
			long[][] arr = new long[n][];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLongArray(m);
			}
			return arr;
		}

		int[] shuffle(int[] arr) {
			Random r = new Random();
			for (int i = 1, j; i < arr.length; i++) {
				j = r.nextInt(i);
				int c = arr[i];
				arr[i] = arr[j];
				arr[j] = c;
			}
			return arr;
		}

		long[] shuffle(long[] arr) {
			Random r = new Random();
			for (int i = 1, j; i < arr.length; i++) {
				j = r.nextInt(i);
				long c = arr[i];
				arr[i] = arr[j];
				arr[j] = c;
			}
			return arr;
		}

		int[] uniq(int[] arr) {
			Arrays.sort(arr);
			int[] rv = new int[arr.length];
			int pos = 0;
			rv[pos++] = arr[0];
			for (int i = 1; i < arr.length; i++) {
				if (arr[i] != arr[i - 1]) {
					rv[pos++] = arr[i];
				}
			}
			return Arrays.copyOf(rv, pos);
		}

		long[] uniq(long[] arr) {
			Arrays.sort(arr);
			long[] rv = new long[arr.length];
			int pos = 0;
			rv[pos++] = arr[0];
			for (int i = 1; i < arr.length; i++) {
				if (arr[i] != arr[i - 1]) {
					rv[pos++] = arr[i];
				}
			}
			return Arrays.copyOf(rv, pos);
		}

		int[] reverse(int[] arr) {
			int l = 0, r = arr.length - 1;
			while (l < r) {
				arr[l] = arr[l] ^ arr[r];
				arr[r] = arr[l] ^ arr[r];
				arr[l] = arr[l] ^ arr[r];
				l++;
				r--;
			}
			return arr;
		}

		long[] reverse(long[] arr) {
			int l = 0, r = arr.length - 1;
			while (l < r) {
				arr[l] = arr[l] ^ arr[r];
				arr[r] = arr[l] ^ arr[r];
				arr[l] = arr[l] ^ arr[r];
				l++;
				r--;
			}
			return arr;
		}
	}
}