/*
 * @Author: Floze3
 * @Date: 2024-11-02 08:42:38
 * @LastEditors: Floze3 [email protected]
 * @LastEditTime: 2024-11-02 09:22:47
 * @FilePath: /dmy/NOIPDay2/A.cpp
 * @Description: Coding
 * Never Be Alone
 */
#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#ifdef CPH
#include "/home/floze3/OI/debug.cpp"
#else 
#include "/home/floze3/OI/debug_colored.cpp"
#endif
#else
#define debug(...)
#define debugArr(...)
#define look_time
#define look_memory
#endif
#define mp(x, y) std::make_pair(x, y)
#define mt std::make_tuple
#define eb emplace_back
#define fi first
#define se second
#define all(s) s.begin(), s.end()
#define rall(s) s.rbegin(), s.rend()
#define file(name)                 \
  freopen(name ".in", "r", stdin); \
  freopen(name ".out", "w", stdout);
#define fs(x) std::fixed << std::setprecision(x)
#define lowbit(x) (x & -x)
#define il inline
#define Avada_Kedavra return 0
#define _IOS                        \
  std::ios::sync_with_stdio(false); \
  std::cin.tie(nullptr), std::cout.tie(nullptr)
#define RANDOM_SEED std::chrono::steady_clock::now().time_since_epoch().count()
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
#define multitask    \
  int _; rd >> _; \
  while (_--)
using std::cerr;

namespace TYPEDEF {

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;
using i128 = __int128;
using pii = std::pair<int, int>;
using pi64 = std::pair<i64, i64>;
using vi = std::vector<int>;
using vi64 = std::vector<i64>;
using vu64 = std::vector<u64>;
using vpii = std::vector<pii>;
using vpi64 = std::vector<pi64>;
using si = std::stack<int>;
using si64 = std::stack<i64>;
using su64 = std::stack<u64>;
using spii = std::stack<pii>;
using spi64 = std::stack<pi64>;
using qi = std::queue<int>;
using qi64 = std::queue<i64>;
using qu64 = std::queue<u64>;
using qpii = std::queue<pii>;
using qpi64 = std::queue<pi64>;
using siset = std::set<int>;
using si64set = std::set<i64>;
using su64set = std::set<u64>;
using spiiset = std::set<pii>;
using spi64set = std::set<pi64>;
using str = std::string;
using vstr = std::vector<str>;
using f64 = long double;

} // namespaec TYPEDEF

using namespace TYPEDEF;

struct Scanner {
  FILE* stream;
  Scanner(FILE* s): stream(s) {}
  char buf[1 << 20], *l = buf, *r = buf;
  bool flush() { l = buf; r = l + fread(buf, 1, 1 << 20, stream); return l == r; }
  void get(char& c) {
#ifndef ONLINE_JUDGE
    c = getchar();
#else
    c = l == r && flush() ? ' ' : *l++;
#endif
  }

  friend Scanner &operator>>(Scanner &in, char& c) { return in.get(c), in; }

  friend Scanner &operator>>(Scanner &in, char* s) {
    for (in.get(s[0]); isspace(s[0]); in.get(s[0]));
    for (int i = 0; !isspace(s[i]) || (s[i] = '\0'); i++) in.get(s[i + 1]);
    return in;
  }

  friend Scanner &operator>>(Scanner &in, std::string &s) {
    char c;
    for (in.get(c); isspace(c); in.get(c));
    for (s = ""; !isspace(c); in.get(c)) s += c;
    return in;
  }

  friend Scanner &operator>>(Scanner &in, i128 &x) {
    char c, f = '+';
    for (in.get(c); !isdigit(c); in.get(c))
      if (c == '-') f = c;
    for (x = 0; isdigit(c); in.get(c)) x = (x << 1) + (x << 3) + c - '0';
    if (f == '-') x = -x;
    return in;
  }

  template<class T> friend Scanner &operator>>(Scanner &in, T &x) {
    if (std::is_integral<T>()) {
      char c, f = '+';
      for (in.get(c); !isdigit(c); in.get(c))
        if (c == '-') f = c;
      for (x = 0; isdigit(c); in.get(c)) x = (x << 1) + (x << 3) + c - '0';
      if (f == '-') x = -x;
      return in;
    }
    else {
      std::string s;
      in >> s;
      x = std::stod(s);
      return in;
    }
  }
};

struct Printer {
  FILE* stream;
  Printer(FILE* s): stream(s) {}
  char buf[1 << 20], *l = buf, *r = buf + (1 << 20) - 1;
  int format = 0, precision = 15;
  ~Printer() { flush(); }

  void flush() { fwrite(buf, 1, l - buf, stream); l = buf; }
  void put(const char& c) {
#ifndef ONLINE_JUDGE
    putchar(c);
#else
    *l++ = c;
    if (l == r) flush();
#endif
  }

  friend Printer &operator<<(Printer &out, const char &c) {
    return out.put(c), out;
  }

  friend Printer &operator<<(Printer &out, const char* s) {
    for (int i = 0; s[i] != '\0'; i++) out.put(s[i]);
    return out;
  }

  friend Printer &operator<<(Printer &out, const std::string &s) {
    for (int i = 0, n = s.size(); i < n; i++) out.put(s[i]);
    return out;
  }

  friend Printer &operator<<(Printer &out, i128 x) {
    static int s[40], top = 0;
    if (x < 0) out.put('-'), x = -x;
    do s[++top] = x % 10, x /= 10; while (x);
    while (top) out.put(s[top--] + '0');
    return out;
  }

  template<class T> friend Printer &operator<<(Printer &out, T x) {
    if (std::is_integral<T>()) {
      static int s[40], top = 0;
      int nx = x;
      if (nx < 0) out.put('-'), nx = -nx;
      do s[++top] = nx % 10, nx /= 10; while (nx);
      while (top) out.put(s[top--] + '0');
      return out;
    }
    else {
      std::ostringstream oss;
      oss << std::fixed << std::setprecision(out.precision) << x;
      return out << oss.str();
    }
    return out;
  }
};

Scanner rd(stdin);
Printer wt(stdout);

/*===============================ALGOS===============================*/

namespace basic_algorithm {
template <typename T> il T abs(T a) { return a >= 0 ? a : -a; }
template <typename T> il void chmin(T &a, T b) { if (a > b) a = b; }
template <typename T> il void chmax(T &a, T b) { if (a < b) a = b; }
}  // namespace basic_algorithm

using namespace basic_algorithm;

/*================================END================================*/

constexpr int N = 2e5 + 5;
constexpr int mod = 1e9 + 7;
constexpr int inf = 0x3f3f3f3f;
constexpr i64 inf64 = 0x3f3f3f3f3f3f3f3fll;

std::mt19937 rng(RANDOM_SEED);

bool mst;

int n, a[N], b[N], in[N], res[N], cur, pos[N];

vi g[N];

bool med;

signed main() {
  rd >> n;
  for (int i = 1; i <= n; ++i) rd >> a[i];
  for (int i = 1; i <= n; ++i) rd >> b[i];
  for (int i = 1; i <= n; ++i) {
    if (a[i] > 1) g[pos[a[i] - 1]].eb(i), ++in[i];
    if (pos[a[i]]) g[i].eb(pos[a[i]]), ++in[pos[a[i]]];
    pos[a[i]] = i;
  }
  for (int i = 1; i <= n; ++i) pos[i] = 0;
  for (int i = n; i; --i) {
    if (b[i] > 1) g[pos[b[i] - 1]].eb(i), ++in[i];
    if (pos[b[i]]) g[i].eb(pos[b[i]]), ++in[pos[b[i]]];
    pos[b[i]] = i;
  }
  qi q;
  for (int i = 1; i <= n; ++i) 
    if (!in[i]) q.push(i);
  while (!q.empty()) {
    int u = q.front(); q.pop();
    res[u] = ++cur;
    for (int v : g[u]) {
      if (!(--in[v])) q.push(v);
    }
  }
  for (int i = 1; i <= n; ++i) wt << res[i] << ' ';
  Avada_Kedavra;
}

/*
all the things you do
the words you say
it all comes back to you
*/