Let's define the sum of two permutations *p* and *q* of numbers 0, 1, ..., (*n* - 1) as permutation <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/a6967136eb87d05a01f795f6061b884a1a9f4f4b.png" style="max-width: 100.0%;max-height: 100.0%;"/>, where *Perm*(*x*) is the *x*-th lexicographically permutation of numbers 0, 1, ..., (*n* - 1) (counting from zero), and *Ord*(*p*) is the number of permutation *p* in the lexicographical order.

For example, *Perm*(0) = (0, 1, ..., *n* - 2, *n* - 1), *Perm*(*n*! - 1) = (*n* - 1, *n* - 2, ..., 1, 0)

Misha has two permutations, *p* and *q*. Your task is to find their sum.

Permutation *a* = (*a*<sub class="lower-index">0</sub>, *a*<sub class="lower-index">1</sub>, ..., *a*<sub class="lower-index">*n* - 1</sub>) is called to be lexicographically smaller than permutation *b* = (*b*<sub class="lower-index">0</sub>, *b*<sub class="lower-index">1</sub>, ..., *b*<sub class="lower-index">*n* - 1</sub>), if for some *k* following conditions hold: *a*<sub class="lower-index">0</sub> = *b*<sub class="lower-index">0</sub>, *a*<sub class="lower-index">1</sub> = *b*<sub class="lower-index">1</sub>, ..., *a*<sub class="lower-index">*k* - 1</sub> = *b*<sub class="lower-index">*k* - 1</sub>, *a*<sub class="lower-index">*k*</sub> &lt; *b*<sub class="lower-index">*k*</sub>.
The first line contains an integer *n* (1 ≤ *n* ≤ 200 000).

The second line contains *n* distinct integers from 0 to *n* - 1, separated by a space, forming permutation *p*.

The third line contains *n* distinct integers from 0 to *n* - 1, separated by spaces, forming permutation *q*.
def sum(BIT, i):
    s = 0
    while i > 0:
        s += BIT[i]
        i -= i & (-i)
    return s


def update(BIT, i, v):
    while i < len(BIT):
        BIT[i] += v

        i += i & (-i)


def find(fen, k):
    curr = 0
    ans = 0
    prevsum = 0
    for i in range(19, -1, -1):
        if ((curr + (1 << i) < n) and fen[curr + (1 << i)] + prevsum < k):
            ans = curr + (1 << i)
            curr = ans
            prevsum += fen[curr]
    return ans + 1

def Rank(x,BIT) :

    return sum(BIT,x)




n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))

factp = []
factq = []




BIT = [0] * (n + 1)
for j in range(n):
    update(BIT,j+1,1)


for val in p:
    factp.append(Rank(val+1,BIT)-1)
    update(BIT,val+1,-1)




BIT = [0] * (n + 1)
for j in range(n):
    update(BIT,j+1,1)


for val in q:
    factq.append(Rank(val+1,BIT)-1)
    update(BIT,val+1,-1)





carry = 0
for i in range(n - 1, -1, -1):
    radix = n - i
    factp[i] = factp[i] + factq[i] + carry
    if factp[i] < radix:
        carru = 0
    else:
        carry = 1
        factp[i] -= radix


BIT = [0] * (n + 1)
for j in range(n):
    update(BIT,j+1,1)
res=[]
for i in range(n):
    k = factp[i]+1
    res.append(find(BIT,k)-1)
    update(BIT,res[-1]+1,-1)

print(*res)