#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#define MAXN 300000
#define MAXC 200000
#define rep(E, F) for (E = 0; E < (F); E++)
#define per(E, F) for (E = (F) - 1; E >= 0; E--)
#define LSB(i) ((i) & -(i))
typedef long long ll;
ll min(ll a, ll b) { if (a > b) return b; return a; }
ll max(ll a, ll b) { if (a < b) return b; return a; }
ll get_int()
{
	ll r = 0, c = getchar(), s = 1;
	while (c != '-' && c < '0' || c > '9') c = getchar();
	while (c == '-') s *= -1, c = getchar();
	while (c >= '0' && c <= '9') r = r*10 + c - '0', c = getchar();
	return s*r;
}

typedef struct { ll x, y, z; } par;
void swap(ll *a, ll *b) { ll s = *a; *a = *b; *b = s; }
int cmp(const void* p1, const void* p2)
{
	ll *a = (ll*)p1, *b = (ll*)p2;
	if (a[0] == b[0]) return a[1] - b[1];
	return a[0] - b[0];
}
ll sum(ll *a, ll i)
{ // [0, i]
    ll r = 0;
	for (i++; i > 0; i -= LSB(i)) r += a[i];
    return r;
}

void add(ll *a, ll n, ll i, ll k)
{
	for (i++; i <= n; i += LSB(i)) a[i] += k;
}

ll count(ll *aa, ll *bb, ll n)
{
	ll i, j, r = 0, f[n + 1], g[n + 1];
	par a[n], b[n];
	rep(i, n + 1) f[i] = g[i] = 0;
	rep(i, n) add(f, n, i, 1), add(g, n, i, 1);
	rep(i, n) a[i].x = aa[i], a[i].y = i, b[i].x = bb[i], b[i].y = i;
	qsort(a, n, sizeof *a, cmp), qsort(b, n, sizeof *b, cmp);
	rep(i, n) a[i].z = b[i].y;
	rep(i, n) b[i].y = a[i].y;
	rep(i, n) swap(&a[i].x, &a[i].y);
	qsort(a, n, sizeof *a, cmp);
	rep(i, n) swap(&a[i].x, &a[i].y);
	rep(i, n)
	{
		j = b[i].y;
		r += llabs(sum(f, a[j].z) - sum(g, j));
		add(g, n, j, -1);
		add(f, n, a[j].z, -1);
	}
	return r;
}

typedef struct { ll p[MAXN], a[MAXN], b[MAXN]; } uf;
void init(uf *u)
{
	ll i;
	rep(i, MAXN) u->p[i] = -1, u->a[i] = u->b[i] = i;
}
ll find(uf *u, ll x)
{
	return u->p[x] < 0 ? x : (u->p[x] = find(u, u->p[x]));
}
void join(uf *u, ll x, ll y)
{
	ll rx = find(u, x), ry = find(u, y);
	if (rx == ry) return;
	if (u->p[rx] > u->p[ry])
		u->a[ry] = min(u->a[ry], u->a[rx]),
		u->b[ry] = max(u->b[ry], u->b[rx]),
		u->p[ry] += u->p[rx],
		u->p[rx] = ry;
	else
		u->a[rx] = min(u->a[ry], u->a[rx]),
		u->b[rx] = max(u->b[ry], u->b[rx]),
		u->p[rx] += u->p[ry],
		u->p[ry] = rx;
}
ll ufmin(uf *u, ll x) { return u->a[find(u, x)]; }
ll ufmax(uf *u, ll x) { return u->b[find(u, x)]; }

void move_right(par* a, ll *aa, ll *c, ll n, ll x, uf *l, uf *r)
{ // move element at a[i].y in |aa| to the right
	assert(a[x].y != n - 1);
	ll k = ufmax(r, a[x].y + 1);
	printf("%lld %lld\n", a[x].y + 1, k + 1);
	swap(&aa[a[x].y], &aa[a[c[k]].y]);
	swap(&a[x].y, &a[c[k]].y);
	c[a[c[k]].y] = c[k], c[a[x].y] = x;
}

void move_left(par* a, ll *aa, ll *c, ll n, ll x, uf *l, uf *r)
{
	assert(a[x].y != 0);
	ll k = ufmin(l, a[x].y - 1);
	printf("%lld %lld\n", a[x].y + 1, k + 1);
	swap(&aa[a[x].y], &aa[a[c[k]].y]);
	swap(&a[x].y, &a[c[k]].y);
	c[a[c[k]].y] = c[k], c[a[x].y] = x;
}

uf l, r;
ll moves(ll *aa, ll *bb, ll n)
{ // this alters the array |aa|.
	ll i, j, x = 0, c[n];
	init(&l), init(&r);
	// a stores {val, curr index}
	// b stores {val, target index}
	// c stores where the ith element of aa is in a
	par a[n], b[n];
	rep(i, n) a[i].x = aa[i], a[i].y = i, b[i].x = bb[i], b[i].y = i;
	qsort(a, n, sizeof *a, cmp), qsort(b, n, sizeof *b, cmp);
	rep(i, n) c[a[i].y] = i;
	rep(i, n)
	{ // we need to start at the smallest guy
		while (x < MAXC && a[i].y != b[i].y) a[i].y < b[i].y ? (move_right(a, aa, c, n, i, &l, &r)) : (move_left(a, aa, c, n, i, &l, &r)), x++;
		if (x == MAXC) break; // this ensures a[i].y == b[i].y
		if (a[i].y != 0) join(&l, a[i].y, a[i].y - 1);
		if (a[i].y != n - 1) join(&r, a[i].y, a[i].y + 1);
	}
	return x;
}

int main()
{
	ll i, j, n = get_int();
	ll a[n], b[n];
	rep(i, n) a[i] = get_int();
	rep(i, n) b[i] = get_int();
	printf("%lld\n", count(a, b, n));
	moves(a, b, n);
	return 0;
}