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 tr4 {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
	    int n=sc.nextInt();
	    int []a=new int [n];
	    int []b=new int [n];
	    TreeMap <Integer,Integer> tm=new TreeMap<>();
	    for(int i=0;i<n;i++)
	    	a[i]=sc.nextInt();
	    for(int i=0;i<n;i++) {
	    	b[i]=sc.nextInt();
	    	tm.put(b[i], tm.getOrDefault(b[i], 0)+1);
	    }
	    int []c=new int [n];
	    for(int i=0;i<n;i++) {
	    	if(a[i]==0) {
	    		c[i]=tm.firstKey();
	    		if(tm.get(tm.firstKey())==1)
	    			tm.remove(tm.firstKey());
	    		else
	    			tm.put(tm.firstKey(), tm.get(tm.firstKey())-1);
	    	}
	    	else {
	    		int t=n-a[i];
	    		if(tm.containsKey(t)) {
	    			c[i]=0;
	    			if(tm.get(t)==1)
		    			tm.remove(t);
		    		else
		    			tm.put(t, tm.get(t)-1);
	    		}
	    		else {
	    			if(tm.ceilingKey(t)==null) {
	    				c[i]=tm.firstKey()+a[i];
	    	    		if(tm.get(tm.firstKey())==1)
	    	    			tm.remove(tm.firstKey());
	    	    		else
	    	    			tm.put(tm.firstKey(), tm.get(tm.firstKey())-1);
	    	    		continue;
	    			}
	    			int t1=tm.ceilingKey(t);
	    			if((t1+a[i])%n<=(t+a[i])) {
	    				c[i]=(t1+a[i])%n;
	    				if(tm.get(t1)==1)
			    			tm.remove(t1);
			    		else
			    			tm.put(t1, tm.get(t1)-1);
	    			}
	    			else {
	    				c[i]=tm.firstKey()+a[i];
	    	    		if(tm.get(tm.firstKey())==1)
	    	    			tm.remove(tm.firstKey());
	    	    		else
	    	    			tm.put(tm.firstKey(), tm.get(tm.firstKey())-1);
	    			}
	    		}
	    	}
	    //	System.out.println(tm);
	    }
	    for(int u:c)
	    	out.print(u+" ");
		out.flush();
	}

	static int gcd(int a, int b) {
		if (b == 0) {
			return a;
		}
		return gcd(b, a % b);
	}

	static class seg implements Comparable<seg> {
		int s;
		int e;

		seg(int s, int e) {
			this.s = s;
			this.e = e;
		}

		public String toString() {
			return s + " " + e;
		}

		public int compareTo(seg t) {
			if (t.s != s)
				return s - t.s;
			return -e + t.e;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

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

		public Scanner(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 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);
		}
	}
}