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.Scanner;

/**
 *
 * @author htdong
 * @date 2018年4月20日 上午11:52:19
 */

public class Main {
    
    static class CodeForces {
        private int[] tr;

        private int idx(int l, int r) {
            return (l + r) | (l != r ? 1 : 0);
        }

        public void build(int n) {
            tr = new int[n << 1];
        }

        public void add(int l, int r, int x) {
            if (l == r) {
                ++tr[idx(l, r)];
                return;
            }
            int mid = l + r >> 1;
            if (x <= mid) {
                add(l, mid, x);
            } else {
                add(mid + 1, r, x);
            }
            tr[idx(l, r)] = tr[idx(l, mid)] + tr[idx(mid + 1, r)];
        }

        public int query(int l, int r, int s, int t) {
            int rlt = -1;
            if (l == r) {
                if (tr[idx(l, r)] > 0) {
                    --tr[idx(l, r)];
                    rlt = l;
                }
                return rlt;
            }
            int mid = l + r >> 1;
            if (s <= mid && tr[idx(l, mid)] > 0) {
                rlt = query(l, mid, s, t);
            }
            if (rlt < 0 && t > mid) {
                rlt = query(mid + 1, r, s, t);
            }
            tr[idx(l, r)] = tr[idx(l, mid)] + tr[idx(mid + 1, r)];
            return rlt;
        }
    }

    public static void main(String[] args) {
        CodeForces t = new CodeForces();
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        t.build(n);
        for (int i = 0; i < n; ++i) {
            a[i] = in.nextInt();
        }
        for (int i = 0; i < n; ++i) {
            t.add(0, n - 1, in.nextInt());
        }
        for (int i = 0; i < n; ++i) {
            int q1 = t.query(0, n - 1, (n - a[i]) % n, n - 1);
            if (q1 < 0) {
                q1 = t.query(0, n - 1, 0, n - a[i] - 1);
            }
            System.out.print((q1 + a[i]) % n);
            if (i == n - 1) {
                System.out.println();
            } else {
                System.out.print(" ");
            }
        }
        in.close();
    }
}