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()

MX = 2 * 10 ** 5 + 10
lt = [0] * MX
rt = [0] * MX
k = [0] * MX
pr = [0.0] * MX
cur = 1

def merge(left, right):
    if not left: return right
    if not right: return left
    if pr[left] > pr[right]:
        rt[left] = merge(rt[left], right)
        return left
    lt[right] = merge(left, lt[right])
    return right


def erase(n, key):
    if not n: return n
    if key == k[n]:
        return merge(lt[n], rt[n])
    if key < k[n]:
        lt[n] = erase(lt[n], key)
    else:
        rt[n] = erase(rt[n], key)
    return n


def lower_bound(n, key):
    if not n: return n
    if key > k[n]:
        return lower_bound(rt[n], key)
    if key < k[n]:
        r = lower_bound(lt[n], key)
        if r and k[r] >= key:
            return r
    return n


def main():
    n = int(readline())
    a = readlist()
    _b = sorted(map(int, readline().split()))

    def build(i, j):
        global cur
        if i == j:
            return 0
        mid = (i + j) // 2
        root = cur
        cur += 1
        pr[root] = random.random()
        k[root] = _b[mid]
        lt[root] = build(i, mid)
        rt[root] = build(mid + 1, j)
        return root

    b = build(0, len(_b))
    for ai in a:
        it = lower_bound(b, n - ai)
        if not it:
            ptr = b
            while lt[ptr]:
                ptr = lt[ptr]
            it = ptr
        print((k[it] + ai) % n, end=' ')
        b = erase(b, k[it])


# 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()