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

public class CFP {

    public static void main(String[] args) {
        /*long time = System.nanoTime();
        System.out.println((System.nanoTime()-time)/1000000+": test");
        time = System.nanoTime();*/
        
        int length = 0;
        int[] a = null;
        TreeMap<Integer, Integer> b = null;
        try (BufferedReader reader = new BufferedReader(/*new FileReader("C:\\Users\\Matúš\\Desktop\\in.txt")*/new InputStreamReader(System.in))) {
            length = Integer.parseInt(reader.readLine());
            a = new int[length];
            b = new TreeMap<Integer, Integer>();
            
            /*System.out.println((System.nanoTime()-time)/1000000+": init");
            time = System.nanoTime();*/
            int c = reader.read();
            for (int i=0; i<length; i++) {
                while (c < '0') {
                    c = reader.read();
                }
                while (c >= '0') {
                    a[i] = a[i] * 10 + c - '0';
                    c = reader.read();
                }
            }
            
            /*System.out.println((System.nanoTime()-time)/1000000+": a");
            time = System.nanoTime();*/
            int d;
            for (int i=0; i<length; i++) {
                d = 0;
                while (c < '0') {
                    c = reader.read();
                }
                while (c >= '0') {
                    d = d * 10 + c - '0';
                    c = reader.read();
                }
                if ( b.containsKey(d) ) {
                    b.put(d, b.get(d)+1);
                } else {
                    b.put(d, 1);
                }
            }
        } catch (IOException e) {}
        /*System.out.println((System.nanoTime()-time)/1000000+": b");
        time = System.nanoTime();*//*
        b.sort(null);
        System.out.println((System.nanoTime()-time)/1000000+": sort");
        time = System.nanoTime();*/
        
        PrintWriter writer = new PrintWriter(System.out);
        for (int i=0; i<length; i++) {
            Integer search = (length - a[i]) % length;/*
            int j = Collections.binarySearch(b, search);
            writer.print((a[i]+b.remove((j<0?~j:j)%b.size()))%length);*/
            Integer j = b.ceilingKey(search);
            if (j == null) {
                j = b.ceilingKey(0);
            }
            writer.print((a[i]+j)%length);
            writer.write(' ');
            search = b.get(j);
            if (search == 1) {
                b.remove(j);
            } else {
                b.put(j, search-1);
            }
        }
        writer.write('\n');
        writer.flush();
        //System.out.println((System.nanoTime()-time)/1000000+": out");
    }
}
