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

constexpr int maxn = 2 * 7e4 + 100, bkcap = 155, bknr = maxn / bkcap + 5,
              mod = 1e9 + 7;

int n, q, v[maxn] = {}, by_buck[bknr][bkcap] = {}, buck_mul[bknr] = {};
uint8_t buck_sz[bknr] = {}, buck_poz[bknr][maxn] = {};

struct modint {
    int x;
    constexpr modint() : x(0) {}
    constexpr modint(int X) : x((mod + X % mod) % mod) {}
    constexpr modint(const modint& rhs) : x(rhs.x) {}
    operator int() { return x % mod; }

    modint& operator+=(const modint& rhs) {
        x += rhs.x;
        if (x >= mod) x -= mod;
        return *this;
    }

    modint operator+(modint rhs) const { return rhs += *this; }

    modint& operator*=(const modint& rhs) {
        x = ((long long)x * rhs.x) % mod;
        return *this;
    }

    modint operator*(modint rhs) const { return rhs *= *this; }
} ret[maxn] = {}, p2[maxn] = {1}, inv_p2[maxn] = {1}, value[bknr][bkcap] = {},
             buck_sp[bknr][bkcap + 1] = {};

vector<pair<int, modint*>> queries[maxn] = {};

static void precalc() {
    for (int i = 1; i < maxn; ++i) p2[i] = p2[i - 1] * modint(2);

    for (int i = 1; i < maxn; ++i)
        inv_p2[i] = inv_p2[i - 1] * modint((mod + 1) / 2);

    for (int i = 0; i < 2 * n; ++i) buck_poz[v[i] / bkcap][i + 1] = 1;

    for (int i = 0; i < bknr; ++i)
        for (int j = 0; j < 2 * n; ++j) buck_poz[i][j + 1] += buck_poz[i][j];

    for (int i = 0; i < bknr; ++i) buck_sz[i] = buck_poz[i][2 * n];

    for (int i = 0; i < 2 * n; ++i)
        by_buck[v[i] / bkcap][buck_poz[v[i] / bkcap][i]] = v[i];
}

static void set_point_val(int i, modint val) {
    const int b = v[i] / bkcap;

    if (buck_mul[b] < 0) {
        memset(value[b], 0, sizeof(value[b]));
        memset(buck_sp[b], 0, sizeof(buck_sp[b]));
        buck_mul[b] = 0;
    }

    value[b][buck_poz[b][i]] = val *= inv_p2[buck_mul[b]];
    for (int p = buck_poz[b][i] + 1; p <= buck_sz[b]; ++p) buck_sp[b][p] += val;
}

static void brute_force_bucket(int y0, int y1, int _mul) {
    const int b = y0 / bkcap;

    modint mul = _mul < 0 ? modint(0) : p2[_mul], mmu = mul + modint(mod - 1),
           delta = 0;

    for (int i = 0; i < buck_sz[b]; ++i) {
        if (y0 <= by_buck[b][i] && by_buck[b][i] < y1)
            delta += value[b][i] * mmu, value[b][i] *= mul;
        buck_sp[b][i + 1] += delta;
    }
}

static void update(int y0, int y1, int mul) {
    if (y0 == y1) return;

    if (y0 / bkcap == (y1 - 1) / bkcap) {
        brute_force_bucket(y0, y1, mul);
        return;
    }

    if (int y0_ = ((y0 + bkcap - 1) / bkcap) * bkcap; y0 % bkcap) {
        brute_force_bucket(y0, y0_, mul), y0 = y0_;
    }

    if (int y1_ = (y1 / bkcap) * bkcap; y1 % bkcap) {
        brute_force_bucket(y1_, y1, mul);
        y1 = y1_;
    }

    if (mul < 0)
        memset(buck_mul + y0 / bkcap, 0x80,
               sizeof(int) * (y1 / bkcap - y0 / bkcap));
    else
        for (int b0 = y0 / bkcap, b1 = y1 / bkcap; b0 < b1; ++b0)
            buck_mul[b0] += mul;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n;

    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < n; ++j) cin >> v[2 * j + i], --v[2 * j + i];

    for (int i = 0; i < 2 * n; i += 2)
        if (v[i] > v[i + 1]) swap(v[i], v[i + 1]);

    cin >> q;

    for (int i = 0, x, y; i < q; ++i)
        cin >> x >> y, queries[2 * (x - 1)].emplace_back(2 * y, ret + i);

    precalc();

    for (int i = 2 * n - 1, y0, y1, mul; i >= 0; --i) {
        set_point_val(i, inv_p2[i / 2]);

        tie(y0, y1, mul) = (i % 2 ? make_tuple(v[i] + 1, 2 * n, 1)
                                  : make_tuple(0, v[i], (int)0x80808080));

        update(y0, y1, mul);

        if (queries[i].empty()) continue;

        for (int b = 0; b < bknr; ++b)
            if (buck_mul[b] >= 0)
                for (auto [j, r] : queries[i])
                    *r += p2[buck_mul[b]] * buck_sp[b][buck_poz[b][j]];

        for (auto [j, r] : queries[i]) *r *= p2[j / 2 - 1];
    }

    for (int i = 0; i < q; ++i) cout << (int)ret[i] << '\n';
}