#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <math.h>
#include <assert.h>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <iostream>
#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <bitset>

using namespace std;
typedef pair<int, int> Pi;
typedef long long ll;
#define pii Pi
#define pll PL
#define Fi first
#define Se second
#define pb(x) push_back(x)
//#define sz(x) ((int)(x).size())
#define rep(i, n) for(int i=0;i<n;i++)
#define all(x) (x).begin(), (x).end()
typedef tuple<int, int, int> t3;
typedef pair<ll, ll> pll;
typedef long double ldouble;
typedef pair<double, double> pdd;

const double PI = acos(-1);
const double EPS = 1e-9;

const int MX = 1<<17;
const int MM = 1000000007;

struct Tree{
	struct node{
		int add, mn;
	};
	node t[MX*2];
	void update(int l, int r, int v, int n = 1, int s = 0, int e = MX-1){
		if( l <= s && e <= r ){
			t[n].add += v;
			t[n].mn += v;
		}
		else if( r < s || e < l );
		else{
			int m = (s+e) / 2;
			update(l, r, v, n*2, s, m);
			update(l, r, v, n*2+1, m+1, e);
			t[n].mn = min(t[n*2].mn, t[n*2+1].mn) + t[n].add;
		}
	}
	int read(int l, int r, int n = 1, int s = 0, int e = MX-1){
		if( l <= s && e <= r ) return t[n].mn;
		else if( r < s || e < l ) return 1e9;
		else{
			int m = (s+e) / 2;
			return min(read(l, r, n*2, s, m), read(l, r, n*2+1, m+1, e)) + t[n].add;
		}
	}
}tree;

int A[MX], B[MX], C[MX], D[MX], E[MX];
int N, Q;

int V[MX], W[MX];

int addr(int x){ return lower_bound(C+1, C+N+2, x) - C; }

int main()
{
	int ans = 0;
	scanf("%d", &N);
	for(int i = 1; i <= N; i++) scanf("%d%d", A+i, B+i);
	for(int i = 1; i <= N+1; i++) scanf("%d", C+i);

	sort(C+1, C+N+2);
	vector<pii> L, rm;
	for(int i = 1; i <= N; i++){
		int s = addr(B[i]), e = addr(A[i])-1;
		if( s > e ){
			V[addr(A[i])] += 1;
			ans++;
		}
		else{
			V[s] += 1;
			L.emplace_back(s, e);
		}
	}

	for(int i = 1; i <= N+1; i++) V[i] += V[i-1];
	for(int i = 1; i <= N+1; i++) V[i] -= i;
	for(int i = 1; i <= N+1; i++) tree.t[i+MX].mn = V[i];
	for(int i = MX-1; i >= 1; i--) tree.t[i].mn = min(tree.t[i*2].mn, tree.t[i*2+1].mn);
	sort(L.begin(), L.end());

	priority_queue<pii> Q;
	for(pii c : L){
		if( tree.read(c.first, c.second) >= 1 ){
			Q.emplace(c.second, c.first);
			tree.update(c.first, c.second, -1);
		}
		else if(Q.size()){
			pii p = Q.top(); swap(p.first, p.second);
			if( p.second < c.second ) rm.push_back(c);
			else{
				tree.update(p.first, p.second, 1);
				tree.update(c.first, c.second, -1);
				Q.pop(); Q.emplace(c.second, c.first);
				rm.push_back(p);
			}
		}
		else rm.push_back(c);
	}
	ans += Q.size();

	sort(rm.begin(), rm.end(), [](pii l, pii r){
		return l.first != r.first? l.first > r.first : l.second < r.second;
	});

	vector<pii> tmp;
	for(pii c : rm){
		if( !tmp.size() || c.second < tmp.back().second ) tmp.push_back(c);
	}swap(tmp, rm); tmp.clear();

	for(pii c : rm){
		if( tree.read(c.first, c.second) > 0 ) printf("??\n");
		if( tree.read(c.first, c.second) == 0 ){
			tree.update(c.first, c.second, -1);
			tmp.push_back(c);
		}
	}swap(rm, tmp); tmp.clear();
	for(pii c : rm) tree.update(c.first, c.second, 1);

	for(pii &c : rm){
		while(tree.read(c.first, c.first) >= 1 ){
			tree.update(c.first, c.first, -1);
			c.first += 1;
		}
	}

	for(pii c : rm) W[c.first] += 1;
	for(int i = N+1; i >= 1; i--) W[i] += W[i+1];

	int Qn, a, b;
	scanf("%d", &Qn);
	for(int i = 1; i <= Qn; i++){
		scanf("%d%d", &a, &b);
		int s = addr(b), e = addr(a)-1;
		if( s > e ){
			s = addr(a);
			tree.update(s, N+1, 1);
			if( tree.read(1, N+1) < 0 ) printf("-1\n");
			else printf("%d\n", ans + W[s] + 1);
			tree.update(s, N+1, -1);
		}
		else{
			tree.update(s, N+1, 1);
			if( tree.read(1, N+1) < 0 ) printf("-1\n");
			else{
				int tv = ans + W[s];
				if( tree.read(s, e) >= 1 ) tv = max(tv, ans + W[e+1] + 1);
				printf("%d\n", tv);
			}
			tree.update(s, N+1, -1);
		}
	}
}


Measured memory_bytes: 7540