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

public class Main {
  static Scanner in = new Scanner(System.in);
  static PrintWriter out = new PrintWriter(System.out);

  public static void main(String[] args) {
    int n = in.nextInt();

    int[] conj_a = new int[n];
    TreeMap<Integer, Integer> b_tm = new TreeMap<>();

    for (int i = 0; i < n; i++) {
      int input = in.nextInt();
      conj_a[i] = n - input;
    }

    for (int i = 0; i < n; i++) {
      int input = in.nextInt();
      if (b_tm.containsKey(input)) {
        int count = b_tm.get(input) + 1;
        b_tm.replace(input, count);
      } else {
        b_tm.put(input, 1);
      }
    }

    int[] ans = new int[n];

    for (int i = 0; i < n; i++) {
      int min_b = b_tm.firstKey();
      int max_b = b_tm.lastKey();
      // out.println("conj a: " + conj_a[i] + " min b: " + min_b + " max b: " + max_b);
      if (min_b > conj_a[i] || max_b < conj_a[i]) {
        ans[i] = ((n - conj_a[i]) + min_b) % n;
        int count = b_tm.get(min_b) - 1;
        if (count == 0) {
          b_tm.remove(min_b);
        } else {
          b_tm.replace(min_b, count);
        }
      } else {
        Map.Entry least = b_tm.ceilingEntry(conj_a[i]);
        // out.println("least key: " + least.getKey());
        ans[i] = (int)least.getKey() - conj_a[i];
        // out.println("counter curr: " + least.getValue());
        int count = (int)least.getValue() - 1;
        if (count == 0) {
          b_tm.remove(least.getKey());
        } else {
          b_tm.replace((int)least.getKey(), count);
        }
      }
    }

    for (int answer : ans) {
      out.print(answer + " ");
    }

    out.println();

    // for (Map.Entry mapEntry : b_tm.entrySet()) {
    //   out.println(mapEntry.getKey() + " " + mapEntry.getValue());
    // }

    in.close();
    out.close();
  }
}