#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int inf = 1e9 + 7;

struct SegmentTree {
    vector<int> t;
    int sz;

    void init(int m) {
        sz = 1 << __lg(m) + !!(m & (m - 1));
        t.assign(2 * sz, inf);
    }

    void rangeApply(int l, int r, int x) {
        for (l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
            if (l & 1) {
                t[l] = min(t[l], x);
                l += 1;
            }
            if (r & 1) {
                r -= 1;
                t[r] = min(t[r], x);
            }
        }
    }

    int rangeMin(int l, int r) {
        int ans = inf;
        for (l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
            if (l & 1) {
                ans = min(ans, t[l++]);
            }
            if (r & 1) {
                ans = min(ans, t[--r]);
            }
        }
        return ans;
    }

    int query(int x) {
        int ans = inf;
        for (ans = t[x += sz]; x >>= 1; ) {
            ans = min(ans, t[x]);
        }
        return ans;
    }

    void modify(int x, int f) {
        x += sz;
        t[x] = min(t[x], f);
        while (x >>= 1) {
            t[x] = min(t[x << 1], t[x << 1 | 1]);
        }
    }
};

template<typename T>
struct Fenwick {
    int n;
    vector<T> a;

    Fenwick() = default;

    explicit Fenwick(int n) : n(n), a(n + 1) {}

    void modify(int x, T v) {
        for (int i = x + 1; i <= n; i += i & -i) {
            a[i] += v;
        }
    }

    void modify(int l, int r, T v) {
        if (l >= r) return;
        modify(l, v), modify(r, -v);
    }

    T sum(int x) {
        T ans = 0;
        for (int i = x + 1; i > 0; i -= i & -i) {
            ans += a[i];
        }
        return ans;
    }

    T rangeSum(int l, int r) { //[l, r)
        if (l >= r) return 0;
        return sum(r - 1) - sum(l - 1);
    }

    int kth(T k) {
        int x = 0;
        for (int i = 1 << __lg(n); i; i >>= 1) {
            if (x + i <= n && k > a[x + i]) {
                x += i;
                k -= a[x];
            }
        }
        return x;
    }
};


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

    int n;
    cin >> n;

    vector<int> a(n), b(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        --a[i];
    }
    for (int i = 0; i < n; ++i) {
        cin >> b[i];
        --b[i];
    }

    vector<int> L(n, -1), R(n, n);
    for (int t = 0; t < 2; ++t) {
        SegmentTree tree, range;
        tree.init(100), range.init(100);
        vector<int> res(n, n);
        for (int i = n - 1; i >= 0; --i) {
            res[i] = min({res[i], tree.query(a[i]), tree.query(b[i]), range.rangeMin(b[i], a[i])});
            tree.rangeApply(b[i], a[i] + 1, i);
            range.modify(a[i], i);
            range.modify(b[i], i);
        }
        if (t == 0) {
            R = res;
        } else {
            L = res;
            reverse(L.begin(), L.end());
            for (int &x : L) {
                x = n - x - 1;
            }
        }
        reverse(a.begin(), a.end());
        reverse(b.begin(), b.end());
    }

    vector<vector<int>> updates(n + 1);
    for (int i = 0; i < n; ++i) {
        updates[R[i]].push_back(i);
    }

    int q;
    cin >> q;
    vector<vector<pair<int, int>>> queries(n);
    vector<int> answers(q);
    for (int i = 0; i < q; ++i) {
        int l, r;
        cin >> l >> r;
        queries[r - 1].push_back({l - 1, i});
    }

    Fenwick<int> fn(n);
    for (int i = 0; i < n; ++i) {
        if (L[i] >= 0) {
            fn.modify(L[i], 1);
        }
        for (int j : updates[i]) {
            if (L[j] >= 0) {
                fn.modify(L[j], -1);
            }
            fn.modify(j, 1);
        }
        for (auto [l, k] : queries[i]) {
            if (fn.rangeSum(l, i + 1) == i - l + 1) {
                answers[k] = true;
            }
        }
    }

    for (int i = 0; i < q; ++i) {
        cout << (answers[i] ? "Yes\n" : "No\n");
    }

    return 0;
}