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 
//package Contest555_div3;

import java.io.*;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class mainE {
    public static PrintWriter out = new PrintWriter(System.out);
    public static FastScanner enter = new FastScanner(System.in);

    public static void main(String[] args) throws IOException {
        PriorityQueue<Integer> pq=new PriorityQueue<>();
        int n=enter.nextInt();
        int[] a=new int[n];
        int[] b=new int[n];
        int[] was=new int[n];
        int[] right=new int[n];
        int[] left=new int[n];
        for (int i = 0; i <n ; i++) {
            right[i]=(i+1)%n;
            left[i]=(i-1)%n;
        }
        TreeSet<Integer> tree = new TreeSet<>();
        for (int i = 0; i <n ; i++) {
            tree.add(i);
        }
        left[0]=n-1;
        for (int i = 0; i <n ; i++) a[i]=enter.nextInt();
        for (int i = 0; i <n ; i++) b[i]=enter.nextInt();
        sortMergeNoRecursive(b);

        /*System.out.println(tree);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));*/
        for (int i = 0; i <n ; i++) {
            int l=0,r=n-1;
            int m=0;
            while(r-l>=1){
                m=(l+r)/2;
                if(b[m]>=(n-a[i])%n) r=m;
                else l=(m+1);
            }
            m=l;
            if(b[m]<(n-a[i])%n) m=0;
            /*System.out.println(b[m]);
            System.out.println(m);
            System.out.println();*/
            if(was[m]==0){
                tree.remove(m);
                out.print((b[m]+a[i])%n+" ");
                was[m]=1;
            }
            else{
                if(tree.higher(m)==null){
                    int h=tree.higher(-1);
                    tree.remove(h);
                    was[h]=1;
                    out.print((b[h]+a[i])%n+" ");
                }
                else{
                    int h=tree.higher(m);
                    tree.remove(h);
                    was[h]=1;
                    out.print((b[h]+a[i])%n+" ");
                }
            }
            //System.out.println(tree);

        }
        out.close();
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer stok;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

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

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

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

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

        char nextChar() throws IOException {
            return (char) (br.read());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }
    }
    private static void sortMergeNoRecursive(int[] arr) {
        int len = arr.length;
        int n = 1; // кратность сравнений (сравнивать по 1-му элем., 2-м ...)
        int shift; // сдвиг в перебираемом массиве
        int two_size; // количество элементов для 2-го массива
        int[] arr2;
        while (n < len) {
            shift = 0;
            while (shift < len) {
                if (shift + n >= len) break;
                two_size = (shift + n * 2 > len) ? (len - (shift + n)) : n;
                arr2 = merge(Arrays.copyOfRange(arr, shift, shift + n),
                        Arrays.copyOfRange(arr, shift + n, shift + n + two_size));
                for (int i = 0; i < n + two_size; ++i)
                    arr[shift + i] = arr2[i]; // замена на отсортированное
                shift += n * 2;
            }
            n *= 2;
        }
    }

    private static int[] merge(int[] arr_1, int[] arr_2) {
        int len_1 = arr_1.length, len_2 = arr_2.length;
        int a = 0, b = 0, len = len_1 + len_2; // a, b - счетчики в массивах
        int[] result = new int[len];
        for (int i = 0; i < len; i++) {
            if (b < len_2 && a < len_1) {
                if (arr_1[a] > arr_2[b]) result[i] = arr_2[b++];
                else result[i] = arr_1[a++];
            } else if (b < len_2) {
                result[i] = arr_2[b++];
            } else {
                result[i] = arr_1[a++];
            }
        }
        return result;
    }
}



