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*.
#!/usr/bin/python3

import sys

class Tree:
    
    def __init__(self, a, b):
        self.range = (a, b)
        if a == b:
            self.active = 1
            self.left = None
            self.rigt = None
            return
        else:
            mid = (a + b) // 2
            self.left = Tree(a, mid)
            self.right = Tree(mid + 1, b)
            self.active = self.left.active + self.right.active
    
    def find_active(self, a, b):
        if b < self.range[0] or self.range[1] < a:
            return 0
        if a <= self.range[0] and self.range[1] <= b:
            return self.active
        return self.left.find_active(a, b) + self.right.find_active(a, b)
    
    def deactivate(self, x):
        if self.range[0] == x and self.range[1] == x:
            self.active = 0
            return
        if x < self.range[0] or self.range[1] < x:
            return
        self.left.deactivate(x)
        self.right.deactivate(x)
        self.active = self.left.active + self.right.active        

    def find_ith(self, x):
        if self.range[0] == self.range[1]:
            return self.range[0]
        if self.left.active >= x:
            return self.left.find_ith(x)
        else:
            return self.right.find_ith(x - self.left.active)

def convert(p, n):
    t = Tree(0, n-1)
    ret = []
    for x in p:
        ret.append(t.find_active(0, x) - 1)
        t.deactivate(x)
    return ret

def perm_sum(p, q):
    n = len(p)
    ret = [0 for i in range(n)]
    prenos = 0
    for i in range(1, n):
        s = p[n-i-1] + q[n-i-1] + prenos
        ret[n-i-1] = s % (i + 1)
        prenos = 1 if s > i else 0
    return ret

def de_convert(p, n):
    t = Tree(0, n-1)
    ret = []
    for x in p:
        d = t.find_ith(x + 1)
        ret.append(d)
        t.deactivate(d)
    return ret    

n = int(sys.stdin.readline())
p = [int(x) for x in sys.stdin.readline().split()]
q = [int(x) for x in sys.stdin.readline().split()]

p = convert(p, n)
q = convert(q, n)
r = de_convert(perm_sum(p, q), n)

print(' '.join(str(x) for x in r))
