#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

struct Fenwick {
  vector<int> b;
  Fenwick(int n) : b(n + 1) {}
  void add(int p, int v) {
    for (++p; p < (int)b.size(); p += p & -p)
      b[p] += v;
  }
  int query(int p) {
    int r = 0;
    for (++p; p > 0; p -= p & -p)
      r += b[p];
    return r;
  }
};

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n;
  cin >> n;

  vector<tuple<int,int>> A, B;
  vector<int> orig_g(n);

  for (int i = 0; i < n; i++) {
    int g;
    cin >> g;
    orig_g[i] = g;
    A.emplace_back(g, i);
  }
  for (int i = 0; i < n; i++) {
    int h;
    cin >> h;
    B.emplace_back(h, i);
  }

  sort(all(A));
  sort(all(B));

  vector<int> pos(n);
  iota(all(pos), 0);
  vector<int> seq(n);
  iota(all(seq), 0);

  vector<int> the_goal(n);

  vector<vector<pair<int,int>>> e;
  for (int i = 0, j; i < n; i = j) {
    e.emplace_back();
    for (j = i; j < n; j++) {
      if (get<0>(A[i]) != get<0>(A[j])) break;
      int cur = get<1>(A[j]);
      int goal = get<1>(B[j]);
      the_goal[cur] = goal;
      e.back().emplace_back(cur, goal);
    }
  }

  const int C = 200000;

  vector<pair<int,int>> sol;

  set<int> st;
  for (int i = 0; i < n; i++)
    st.insert(i);

  auto get_next = [&](int x) {
    return *st.upper_bound(x);
  };
  auto get_prev = [&](int x) {
    return *prev(st.lower_bound(x));
  };


  long long ans = 0;

  Fenwick af(n), bf(n);
  for (const auto &es : e) {
    for (auto [orig_pos, goal] : es) {
      int ap = orig_pos - af.query(orig_pos);
      int bp = goal - bf.query(goal);
      ans += abs(ap - bp);
    }
    for (auto [orig_pos, goal] : es) {
      af.add(orig_pos, 1);
      bf.add(goal, 1);
    }
  }

  for (const auto &es : e) {
    vector<pair<int,int>> tmp;
    for (auto [orig_pos, goal] : es) {
      debug(orig_pos, pos[orig_pos]);
      tmp.emplace_back(pos[orig_pos], -1);
      tmp.emplace_back(goal, 1);
    }
    sort(all(tmp));

    safe;
    debug(es.size());

    int tot = 0;
    vector<int> stk;
    for (auto [_, c] : tmp) {
      tot += c;
      if (c < 0)
        stk.emplace_back(_);

      if (tot == 0) {
        if (c > 0) {
          for (int p : stk | views::reverse) {
            int orig_pos = seq[p];
            debug(orig_pos);
            assert(p <= the_goal[orig_pos]);
            while (p < the_goal[orig_pos]) {
              int q = get_next(p);
              sol.emplace_back(p, q);
              swap(seq[p], seq[q]);
              pos[seq[p]] = p;
              pos[seq[q]] = q;

              swap(orig_g[p], orig_g[q]);
              orange(all(orig_g));
              orange(all(seq));
              debug(p, q, "up");
              p = q;
              if (sol.size() == C)
                goto end;
            }
          }
          stk.clear();
        } else {
          for (int p : stk) {
            int orig_pos = seq[p];
            debug(orig_pos);
            assert(p >= the_goal[orig_pos]);

            debug(the_goal[orig_pos], orig_pos);

            while (p > the_goal[orig_pos]) {
              int q = get_prev(p);
              sol.emplace_back(p, q);
              swap(seq[p], seq[q]);
              pos[seq[p]] = p;
              pos[seq[q]] = q;

              swap(orig_g[p], orig_g[q]);
              orange(all(orig_g));
              orange(all(seq));
              debug(p, q, "down");
              p = q;
              if (sol.size() == C)
                goto end;
            }
          }
          stk.clear();
        }
      }
    }

    for (auto [orig_pos, goal] : es) {
      assert(pos[orig_pos] == goal);
      st.erase(pos[orig_pos]);
    }

    orange(all(st));

  }

end:
  cout << ans << '\n';
  for (auto [x, y] : sol)
    cout << x + 1 << ' ' << y + 1 << '\n';

  return 0;
}