#include <bits/stdc++.h>
using namespace std;
template <class T>
bool setmax(T &_a, T _b) {
  if (_b > _a) {
    _a = _b;
    return true;
  }
  return false;
}
template <class T>
bool setmin(T &_a, T _b) {
  if (_b < _a) {
    _a = _b;
    return true;
  }
  return false;
}
template <class T>
T gcd(T _a, T _b) {
  return _b == 0 ? _a : gcd(_b, _a % _b);
}
template <class T>
class FenwickTree {
  std::vector<T> a;
  int n;
  T v0;

 public:
  FenwickTree() {}
  FenwickTree(int n, T v) : a(size_t(n + 1), v), n(n), v0(v) {}
  void add(int x, T v) {
    for (; x <= n; x += (x & -x)) a[(size_t)x] += v;
  }
  T get(int x) const {
    T r = v0;
    for (; x >= 1; x -= (x & -x)) r += a[(size_t)x];
    return r;
  }
};
class Treap {
  struct Node {
    int val, rkey;
    int l, r, size;
  } tr[200010];
  int num, root;
  void update(int x) { tr[x].size = tr[tr[x].l].size + tr[tr[x].r].size + 1; }
  int lrotate(int x) {
    int y = tr[x].l;
    tr[x].l = tr[y].r;
    tr[y].r = x;
    update(x);
    update(y);
    return y;
  }
  int rrotate(int x) {
    int y = tr[x].r;
    tr[x].r = tr[y].l;
    tr[y].l = x;
    update(x);
    update(y);
    return y;
  }
  int insert(int x, int y) {
    if (x == 0) return y;
    if (tr[y].val < tr[x].val) {
      tr[x].l = insert(tr[x].l, y);
      if (tr[tr[x].l].rkey > tr[x].rkey) x = lrotate(x);
    } else {
      tr[x].r = insert(tr[x].r, y);
      if (tr[tr[x].r].rkey > tr[x].rkey) x = rrotate(x);
    }
    update(x);
    return x;
  }
  int remove(int x, int val) {
    if (tr[x].val == val) {
      if (tr[x].l == 0 && tr[x].r == 0) return 0;
      if (tr[tr[x].l].rkey > tr[tr[x].r].rkey) {
        x = lrotate(x);
        tr[x].r = remove(tr[x].r, val);
      } else {
        x = rrotate(x);
        tr[x].l = remove(tr[x].l, val);
      }
    } else {
      if (val < tr[x].val)
        tr[x].l = remove(tr[x].l, val);
      else
        tr[x].r = remove(tr[x].r, val);
    }
    update(x);
    return x;
  }
  int ask(int x, int ind) {
    assert(ind <= tr[x].size);
    int ls = tr[tr[x].l].size;
    if (ind <= ls) return ask(tr[x].l, ind);
    if (ind == ls + 1) return tr[x].val;
    return ask(tr[x].r, ind - ls - 1);
  }

 public:
  void init() {
    num = root = 0;
    tr[0].rkey = -1;
    tr[0].size = 0;
  }
  void add(int val) {
    int x = ++num;
    tr[x].val = val, tr[x].rkey = rand();
    tr[x].l = tr[x].r = 0, tr[x].size = 1;
    root = insert(root, x);
  }
  void del(int val) { root = remove(root, val); }
  int query(int ind) { return ask(root, ind); }
};
int x[200000], y[200000], z[200000];
int n;
void decode(int a[]) {
  FenwickTree<int> tr(n, 0);
  for (int i = int((n)-1); i >= int(0); --i) {
    tr.add(a[i] + 1, 1);
    a[i] = tr.get(a[i]);
  }
}
void encode(int a[]) {
  static Treap tr;
  tr.init();
  for (int i = int(0); i <= int((n)-1); ++i) tr.add(i);
  for (int i = int(0); i <= int((n)-1); ++i) {
    a[i] = tr.query(a[i] + 1);
    tr.del(a[i]);
  }
}
int main() {
  scanf("%d", &n);
  for (int i = int(0); i <= int((n)-1); ++i) scanf("%d", &x[i]);
  for (int i = int(0); i <= int((n)-1); ++i) scanf("%d", &y[i]);
  decode(x);
  decode(y);
  int r = 0;
  for (int i = int((n)-1); i >= int(0); --i) {
    int num = n - i;
    int cur = x[i] + y[i] + r;
    z[i] = cur % num;
    r = cur / num;
  }
  encode(z);
  for (int i = int(0); i <= int((n)-1); ++i) printf("%d ", z[i]);
  printf("\n");
  return 0;
}
