#!/usr/bin/env python3
import sys

n = int(input())
h = list(map(int, input().split()))
g = list(map(int, input().split()))


class FenwickTree:
    def __init__(self, n):
        self.tree = [0] * (n + 2)

    def query(self, r):
        s = 0
        r += 1
        while r > 0:
            s += self.tree[r]
            r -= r & -r
        return s

    def update(self, i, v):
        i += 1
        while i <= n + 1:
            self.tree[i] += v
            i += i & -i


ph = list(range(n))
pg = list(range(n))
ph.sort(key=lambda i: h[i])
pg.sort(key=lambda i: g[i])
phi = [0] * n
pgi = [0] * n
for i in range(n):
    phi[ph[i]] = i
    pgi[pg[i]] = i

ht, gt = FenwickTree(n), FenwickTree(n)
ans = 0
for k in range(n):
    i = ph[k]
    j = pg[k]
    ht.update(i, 1)
    gt.update(j, 1)
    ans += abs((i - ht.query(i)) - (j - gt.query(j)))
print(ans)

# in-line segtee
class SegTree:
    def __init__(self, n):
        self.n = n + 1
        self.tree = [0] * (2 * self.n)

    def update(self, i, val):
        i += 1
        self.tree[i + self.n] = val
        i = (i + self.n) // 2
        while i > 0:
            self.tree[i] = max(self.tree[2 * i], self.tree[2 * i + 1])

            i //= 2

    def query(self, l, r):
        l += 1
        r += 1
        lhs, rhs = 0, 0
        l += self.n
        r += self.n
        while l < r:
            if l & 1:
                lhs = max(lhs, self.tree[l])
                l += 1
            if not (r & 1):
                rhs = max(self.tree[r], rhs)
                r -= 1

            l >>= 1
            r >>= 1
        return max(max(lhs, self.tree[l]) if l == r else lhs, rhs)

    def findr(self, l, k):
        l += self.n + 2
        while self.tree[l] < k:
            l += 1
            l //= 2
        while l <= self.n:
            l *= 2
            if self.tree[l] < k:
                l += 1
        return l - self.n - 1

    def findl(self, r, k):
        r += self.n
        while self.tree[r] < k:
            r = max(1, (r - 1) // 2)
        while r <= self.n:
            r *= 2
            if self.tree[r + 1] >= k:
                r += 1
        return r - self.n - 1


st = SegTree(n)
for i in range(n):
    st.update(i, h[i])

moves = 0


def make_swap(i, j):
    global moves
    h[i], h[j] = h[j], h[i]
    phi[i], phi[j] = phi[j], phi[i]
    ph[phi[i]], ph[phi[j]] = ph[phi[j]], ph[phi[i]]
    st.update(i, h[i])
    st.update(j, h[j])

    print(i + 1, j + 1)
    moves += 1
    if moves == 200_000:
        exit(0)


for k in range(n):
    i = ph[k]
    j = pg[k]

    while i < j:
        k = st.findr(i, h[i] + 1)
        if k == n:
            break
        i2 = st.findl(k, h[i])
        make_swap(i2, k)
        if i == i2:
            i = k

    while i > j:
        k = st.findl(i, h[i] + 1)
        if k == -1:
            break
        i2 = st.findr(k, h[i])
        make_swap(i2, k)
        if i == i2:
            i = k