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

typedef pair<int, int> pii;

const int MN = 100010;

struct BIT {
    vector<int> tree;
    void init() {
        tree = vector<int>(4 * MN, 1e9);
    }
    void upd(int x, int v, int l, int r, int n) {
        if(x < l || r < x) return;
        if(l == r) {
            tree[n] = v;
            return;
        }
        int m = (l + r)>>1;
        upd(x, v, l, m, 2*n);
        upd(x, v, m + 1, r, 2*n + 1);
        tree[n] = min(tree[2*n], tree[2*n + 1]);
    }
    int quer(int a, int b, int l, int r, int n) {
        if(b < l || r < a) return 1e9;
        if(a <= l && r <= b) return tree[n];
        int m = (l + r)>>1;
        int L = quer(a, b, l, m, 2*n);
        int R = quer(a, b, m + 1, r, 2*n + 1);
        return min(L, R);
    }
} bit;

int N, Q;
pii seg[MN], query[MN];
int C[MN], del1[MN], del2[MN], link[MN], go[MN];
set<pii> st;
vector<int> R, X;

int cc[MN];
int dp(int u) {
    int &ret = cc[u];
    if(ret != -1) return ret;

    int s = u + 1, e = X[0], p = -1;
    while(s <= e) {
        int m = (s + e)>>1;

        if(bit.quer(u, m, 0, MN - 1, 1) <= C[m]) {
            p = m;
            e = m - 1;
        }
        else s = m + 1;
    }

    //cout << u << ' ' << p << endl;

    if(p == -1) return ret = 0;
    else return ret = dp(p) + 1;
}

int calc(int x) {
    if(x > C[ X[0] ]) return -1;
    int a = lower_bound(C, C + X[0] + 1, x) - C;

    //cout << x << ' ' << a << ' ' << dp(a) << endl;

    return dp(a);
}

int main() {
    scanf("%d", &N);

    for(int i = 0; i < N; i++) {
        scanf("%d %d", &seg[i].second, &seg[i].first);
        seg[i].first = min(seg[i].first, seg[i].second);
    }
    for(int i = 0; i < N + 1; i++) {
        scanf("%d", &C[i]);
    }

    scanf("%d", &Q);

    for(int i = 0; i < Q; i++) {
        scanf("%d %d", &query[i].second, &query[i].first);
        query[i].first = min(query[i].first, query[i].second);
    }

    sort(seg, seg + N);
    sort(C, C + N + 1);

    int pos = 0;
    for(int i = 0; i < N + 1; i++) {
        while(pos < N && seg[pos].first <= C[i]) {
            st.insert(pii(seg[pos].second, pos));
            pos++;
        }

        if(st.size() && st.begin()->first <= C[i]) {
            pii t = *st.begin();
            st.erase(t);
            del1[t.second] = 1;
            R.push_back(t.first);

            //cout << t.first << ' ' << t.second << endl;
        }
        else {
            if(st.size()) {
                pii t = *st.rbegin();
                st.erase(t);
            }
        }
    }

    st.clear();
    for(int i = 0; i < N + 1; i++) st.insert(pii(C[i], i));
    for(int i = 0; i < R.size(); i++) {
        pii t = *st.lower_bound(pii(R[i], -1));
        st.erase(t);
        del2[t.second] = 1;
    }

    int x = 0;
    for(int i = 0; i < N + 1; i++) if(!del2[i]) C[x++] = C[i];
    x = 0;
    for(int i = 0; i < N; i++) if(!del1[i]) seg[x++] = seg[i];
    N = x;

    st.clear();
    pos = 0;
    for(int i = 0; i < N + 1; i++) {
        while(pos < N && seg[pos].first <= C[i]) {
            st.insert(pii(seg[pos].second, pos));
            pos++;
        }

        if(st.size()) {
            pii t = *st.rbegin();
            st.erase(t);
            link[i] = t.second;
        }
        else X.push_back(i);
    }

    if(X.size() > 1) {
        for(int i = 0; i < Q; i++) {
            printf("-1\n");
        }
        return 0;
    }

    bit.init();
    for(int i = 0; i < X[0]; i++) {
        bit.upd(i, seg[ link[i] ].second, 0, MN - 1, 1);
    }

    memset(cc, -1, sizeof(cc));

    for(int i = 0; i < Q; i++) {
        int l = query[i].first;
        int r = query[i].second;

        if(C[ X[0] ] < l) {
            printf("-1\n");
            continue;
        }
        int ans = max(calc(l), calc(r) + 1);
        printf("%d\n", ans + R.size());
    }
}
