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

#define F first
#define S second 
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define make_unique(x) sort(all(x)), x.erase(unique(all(x)), x.end())

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 Rng(chrono::steady_clock::now().time_since_epoch().count());

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;

const int N = 1.6e6 + 200;
const int M = 1e9;
const int inf = 2e9 + 3;
const ll INF = 1e18;

template<int mod>
class Modular {
public:
    int val;
    Modular() : val(0) {}
    Modular(int new_val) : val(new_val) {}
    // Modular(long long new_val) : val(new_val % mod) {}  // AFFECTS OPERATOR* (because it has one more %)
    friend Modular operator+(const Modular& a, const Modular& b) {
        if (a.val + b.val >= mod) return a.val + b.val - mod;
        else return a.val + b.val;
    }
    friend Modular operator-(const Modular& a, const Modular& b) {
        if (a.val - b.val < 0) return a.val - b.val + mod;
        else return a.val - b.val;
    }
    friend Modular operator*(const Modular& a, const Modular& b) {
        return 1ll * a.val * b.val % mod;
    }
    friend Modular binpow(Modular a, long long n) {
        Modular res = 1;
        for (; n; n >>= 1) {
            if (n & 1) res *= a;
            a *= a;
        }
        return res;
    }
    /* ALTERNATIVE INVERSE FUNCTION USING EXTENDED EUCLIDEAN ALGORITHM
    friend void gcd(int a, int b, Modular& x, Modular& y) {
        if (a == 0) {
            x = Modular(0);
            y = Modular(1);
            return;
        }
        Modular x1, y1;
        gcd(b % a, a, x1, y1);
        x = y1 - (b / a) * x1;
        y = x1;
    }
    friend Modular inv(const Modular& a) {
        Modular x, y;
        gcd(a.val, mod, x, y);
        return x;
    }
    */
    friend Modular inv(const Modular& a) {
        return binpow(a, mod - 2);
    }
    Modular operator/(const Modular& ot) const {
        return *this * inv(ot);
    }
    Modular& operator++() {
        if (val + 1 == mod) val = 0;
        else ++val;
        return *this;
    }
    Modular operator++(int) {
        Modular tmp = *this;
        ++(*this);
        return tmp;
    }
    Modular operator+() const {
        return *this;
    }
    Modular operator-() const {
        return 0 - *this;
    }
    Modular& operator+=(const Modular& ot) {
        return *this = *this + ot;
    }
    Modular& operator-=(const Modular& ot) {
        return *this = *this - ot;
    }
    Modular& operator*=(const Modular& ot) {
        return *this = *this * ot;
    }
    Modular& operator/=(const Modular& ot) {
        return *this = *this / ot;
    }
    bool operator==(const Modular& ot) const {
        return val == ot.val;
    }
    bool operator!=(const Modular& ot) const {
        return val != ot.val;
    }
    bool operator<(const Modular& ot) const {
        return val < ot.val;
    }
    bool operator>(const Modular& ot) const {
        return val > ot.val;
    }
    explicit operator int() const {
        return val;
    }
};
 
template<int mod>
istream& operator>>(istream& istr, Modular<mod>& x) {
    return istr >> x.val;
}
 
template<int mod>
ostream& operator<<(ostream& ostr, const Modular<mod>& x) {
    return ostr << x.val;
}
 
const int mod = 1e9 + 7;
using Mint = Modular<mod>;

struct node {
    int l, r;
    Mint sum, sumH;
    Mint p;

    node() {
        l = r = 0;
        p = 1;
        sum = sumH = 0;
    }
} t[N << 4];
int sz = 0;

void push(int v, int tl, int tr) {
    if (t[v].p == 1) return;
    if (tl != tr) {
        t[v].l = (t[v].l ? t[v].l : ++sz);
        t[v].r = (t[v].r ? t[v].r : ++sz);
        t[t[v].l].p *= t[v].p;
        t[t[v].r].p *= t[v].p;
    }
    t[v].sum *= t[v].p;
    t[v].sumH *= t[v].p;
    t[v].p = 1;
}

void upd_mul(int l, int r, Mint val, int v = 1, int tl = 0, int tr = M) {
    push(v, tl, tr);
    if (l <= tl && tr <= r) {
        t[v].p *= val;
        push(v, tl, tr);
        return;
    }
    if (r < tl || tr < l)
        return;
    int tm = tl + tr >> 1;
    t[v].l = (t[v].l ? t[v].l : ++sz);
    t[v].r = (t[v].r ? t[v].r : ++sz);
    upd_mul(l, r, val, t[v].l, tl, tm);
    upd_mul(l, r, val, t[v].r, tm + 1, tr);
    t[v].sum = t[t[v].l].sum + t[t[v].r].sum;
    t[v].sumH = t[t[v].l].sumH + t[t[v].r].sumH;
}

void upd(int pos, Mint val, int v = 1, int tl = 0, int tr = M) {
    push(v, tl, tr);
    if (tr < pos || tl > pos) return;
    if (tl == tr) {
        t[v].sum += val;
        t[v].sumH += val * Mint(tl);
        return;
    }
    int tm = tl + tr >> 1;
    t[v].l = (t[v].l ? t[v].l : ++sz);
    upd(pos, val, t[v].l, tl, tm);
    t[v].r = (t[v].r ? t[v].r : ++sz);
    upd(pos, val, t[v].r, tm + 1, tr);
    t[v].sum = t[t[v].l].sum + t[t[v].r].sum;
    t[v].sumH = t[t[v].l].sumH + t[t[v].r].sumH;
}

Mint get(int l, int r, int v = 1, int tl = 0, int tr = M) {
    push(v, tl, tr);
    if (r < tl || tr < l || v == 0)
        return 0;
    if (l <= tl && tr <= r)
        return t[v].sum;
    int tm = tl + tr >> 1;
    return get(l, r, t[v].l, tl, tm) + get(l, r, t[v].r, tm + 1, tr);
}

Mint getH(int l, int r, int v = 1, int tl = 0, int tr = M) {
    push(v, tl, tr);
    if (r < tl || tr < l || v == 0)
        return 0;
    if (l <= tl && tr <= r)
        return t[v].sumH;
    int tm = tl + tr >> 1;
    return getH(l, r, t[v].l, tl, tm) + getH(l, r, t[v].r, tm + 1, tr);
}

int main() {
    ios_base::sync_with_stdio(0), cin.tie(0);
    int n;
    cin >> n;
    int a[n + 1], b[n + 1];
    Mint A[4][n + 1], B[4][n + 1], pw[n + 1];
    pw[0] = 1;
    Mint ans = 0;
    for (int i = 1; i <= n; ++i) {
        pw[i] = pw[i - 1] * Mint(2);
    }
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
        ans = ans - Mint(a[i]) * pw[n - 1];
    }
    for (int i = 1; i <= n; ++i) {
        cin >> b[i];
        ans = ans - Mint(b[i]) * pw[n - 1];
    }
    ++sz;
    upd(0, 1);
    for (int i = 1; i <= n; ++i) {
        if (a[i] > b[i]) swap(a[i], b[i]);
        A[1][i] = get(0, a[i] - 1);
        B[0][i] = get(0, b[i]);
        upd(a[i], A[1][i]);
        upd(b[i], B[0][i]);
        upd_mul(0, a[i] - 1, 0);
        upd_mul(b[i] + 1, M, 2);
        ans = ans + getH(0, M) * pw[n - i];
        if (i == n) {
            ans = ans - getH(0, M) * Mint(n);
        }
    }
    upd_mul(0, M, 0);
    upd(0, 1);
    for (int i = n; i >= 1; --i) {
        A[3][i] = get(0, a[i] - 1);
        B[2][i] = get(0, b[i]);
        upd(a[i], A[3][i]);
        upd(b[i], B[2][i]);
        upd_mul(0, a[i] - 1, 0);
        upd_mul(b[i] + 1, M, 2);
        ans = ans + getH(0, M) * pw[i - 1];
    }
    cout << ans << '\n';
}