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 
#!/usr/bin/env python
from __future__ import division, print_function

# Testing code by c1729

import os
import random
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()

left_child = [0]
right_child = [0]
keys = [0]
priority = [0]


def create_node(key):
    keys.append(key)
    priority.append(random.random())
    left_child.append(0)
    right_child.append(0)
    return len(keys) - 1


def split(root, key):
    if not root:
        return 0, 0
    if key < keys[root]:
        left, left_child[root] = split(left_child[root], key)
        return left, root
    right_child[root], right = split(right_child[root], key)
    return root, right


def merge(left, right):
    tmp = [0]
    where, pos = tmp, 0
    while left and right:
        if priority[left] > priority[right]:
            where[pos] = left
            where, pos = right_child, left
            left = right_child[left]
        else:
            where[pos] = right
            where, pos = left_child, right
            right = left_child[right]
    where[pos] = left or right
    return tmp[0]


def insert(node, key):
    l, r = split(node, key)
    return merge(merge(l, create_node(key)), r)


def erase(root, key):
    if keys[root] == key:
        return merge(left_child[root], right_child[root])
    m = root
    while keys[root] != key:
        parent = root
        root = left_child[root] if key < keys[root] else right_child[root]
    if root == left_child[parent]:
        left_child[parent] = merge(left_child[root], right_child[root])
    else:
        right_child[parent] = merge(left_child[root], right_child[root])
    return m


def lower_bound(root, key):
    while root and keys[root] < key:
        root = right_child[root]
    if not root:
        return 0
    best_node = root
    best = keys[root]
    while root:
        if keys[root] < key:
            root = right_child[root]
        else:
            if keys[root] < best:
                best = keys[root]
                best_node = root
            root = left_child[root]
    return best_node


def main():
    n = int(readline())
    a = readlist()

    b = 0
    for bi in map(int, readline().split()):
        b = insert(b, bi)

    for ai in a:
        it = lower_bound(b, n - ai)
        if not it:
            ptr = b
            while left_child[ptr]:
                ptr = left_child[ptr]
            it = ptr
        cout << (keys[it] + ai) % n << ' '
        b = erase(b, keys[it])
    cout << '\n'


# region template

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._buffer = BytesIO()
        self._fd = file.fileno()
        self._writable = "x" in file.mode or "r" not in file.mode
        self.write = self._buffer.write if self._writable else None

    def read(self):
        if self._buffer.tell():
            return self._buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()

    def flush(self):
        if self._writable:
            os.write(self._fd, self._buffer.getvalue())
            self._buffer.truncate(0), self._buffer.seek(0)


class ostream:
    def __lshift__(self, a):
        if a is endl:
            sys.stdout.write(b"\n")
            sys.stdout.flush()
        else:
            sys.stdout.write(str(a))
        return self


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
cout, endl = ostream(), object()

readline = sys.stdin.readline
readlist = lambda var=int: [var(n) for n in readline().split()]
input = lambda: readline().rstrip(b"\r\n")

# endregion

if __name__ == "__main__":
    main()