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.math.*;
import java.awt.geom.*;
import static java.lang.Math.*;
public class Main implements Runnable
{
    class Node implements Comparable<Node>
    {
        int val, count;

        Node(int v, int c)
        {
            val = v;
            count = c;
        }

        Node(int v)
        {
            val = v;
        }

        @Override
        public int compareTo(Node o)
        {
            return val - o.val;
        }

        @Override
        public String toString()
        {
            return "(" + val + ", " + count + ")";
        }
    }

    boolean multiiple = false;

    void solve() throws Exception
    {
        int n = sc.nextInt();
        TreeSet<Node> b = new TreeSet<>();
        int[] a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = sc.nextInt();

        int[] temp = new int[n];
        for (int i = 0; i < n; i++)
            temp[sc.nextInt()]++;

        for (int i = 0; i < n; i++)
            if (temp[i] != 0)
                b.add(new Node(i, temp[i]));

        for (int i = 0; i < n; i++)
        {
            int target = (n - a[i]) % n;
            if (b.higher(new Node(target - 1)) != null)
            {
                Node response = b.higher(new Node(target - 1));
                if (response.count == 1)
                    b.remove(response);
                else
                    response.count--;

                System.out.print((a[i] + response.val) % n + " ");
            }
            else
            {
                Node response = b.higher(new Node(-1));
                if (response.count == 1)
                    b.remove(response);
                else
                    response.count--;

                System.out.print((a[i] + response.val) % n + " ");
            }
        }
    }

    @Override
    public void run()
    {
        try
        {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            sc = new FastScanner(in);
            if (multiiple)
            {
                int q = sc.nextInt();
                for (int i = 0; i < q; i++)
                    solve();
            }
            else
                solve();
        }
        catch (Throwable uncaught)
        {
            Main.uncaught = uncaught;
        }
        finally
        {
            out.close();
        }
    }

    public static void main(String[] args) throws Throwable {
        Thread thread = new Thread(null, new Main(), "", (1 << 26));
        thread.start();
        thread.join();
        if (Main.uncaught != null) {
            throw Main.uncaught;
        }
    }

    static Throwable uncaught;
    BufferedReader in;
    FastScanner sc;
    PrintWriter out;
}

class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in)
    {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }

}