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.util.*;
import java.io.*;
import java.util.Arrays;
import java.util.TreeMap;
public class Main
{

    public static void main (String[] args)
    {
       int n;
       Scanner input= new Scanner(System.in);
       n =input.nextInt();
       TreeMap<Integer, Integer> b= new TreeMap<Integer, Integer>(); 
       int [] a= new int[n];
       for (int i=0;i<n;i++)
       {
            a[i]= input.nextInt();
            a[i]=a[i]%n;
       }
       for (int i=0;i<n;i++)
       {
            int b1;
            b1= input.nextInt();
            b1=b1%n;
            Integer freq= b.get(b1);
            b.put(b1,freq == null ? 1 : freq + 1);
            
       }
       //System.out.println(b);
       int [] c= new int[n];
       for (int i=0; i<n;i++)
       {
            if (b.ceilingKey(n-a[i])!= null)
            {
                int c1= b.ceilingKey(n-a[i]);
                int c2=b.firstKey();
                if ((c1+a[i])%n > (c2+a[i])%n)
                {
                    c[i]= (c2+a[i])%n;
                    if (b.get(c2)==1)
                    {
                        b.remove(b.firstKey());
                    }
                    else
                    {
                        b.put(c2,b.get(c2)-1);
                    }
                    //System.out.print(c[i]);
                }
                else
                {
                    c[i]= (a[i]+c1)%n;
                    if (b.get(c1)==1)
                    {
                        b.remove(c1);
                    }
                    else
                    {
                        b.put(c1,b.get(c1)-1);
                    }
                   // System.out.print(c[i]);
                }
            }
            else 
            {
                int c1= b.firstKey();
                if (b.get(c1)==1)
                {
                    b.remove(c1);
                }
                else
                {
                    b.put(c1,b.get(c1)-1);
                }
                c[i]=(a[i]+c1)%n;
                //System.out.print(c[i]);
                
            }
       }
       //System.out.println("");
       for (int i=0; i<n;i++)
       {
            System.out.print(c[i]+" ");
       }
       
       
}
    }
