/** @file
 * @ingroup


 */
#include <bits/stdc++.h>
using namespace std;
template <typename T> inline void O(const T &x) { cout << x << '\n'; }
template <typename T, typename... W> inline void O(const T &x, const W &...b) {
  cout << x << ' ';
  O(b...);
}
template <typename T> inline void rd(T &x) { cin >> x; }
template <typename T, typename... W> inline void rd(T &x, W &...b) {
  cin >> x;
  rd(b...);
}
#ifndef MISAKA
#define err(...)
#else
#define err(...) fprintf(stderr, __VA_ARGS__)
#endif
typedef long long i64;
typedef unsigned long long u64;
typedef unsigned u32;
typedef long double dbl;
typedef pair<int, int> pii;
typedef uniform_int_distribution<int> r32;
typedef uniform_int_distribution<i64> r64;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#define shuf(L, R) shuffle((L), (R), rng)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define FOR(i, j, k) for (int i = (j); i <= (k); ++i)
#define ROF(i, j, k) for (int i = (k); i >= (j); --i)
template <typename T> inline void ckmin(T &a, const T &b) { a = min(a, b); }
template <typename T> inline void ckmax(T &a, const T &b) { a = max(a, b); }
//#define IOFILE "insects"
//#define MULTI
const int N = 1e5+5;
typedef vector<int> vi;
typedef vector<pii> vp;

pii l[N], r[N];
#define sort_x(a, t) sort(begin(a), end(a), [] (const auto &a, const auto &b) { return t[a].fi < t[b].fi; })
#define sort_y(a, t) sort(begin(a), end(a), [] (const auto &a, const auto &b) { return t[a].se < t[b].se; })

vp match(vi L, vi R) {
  set<pii> s;
  sort_x(L, l);
  sort_x(R, r);
  auto i = R.begin();
  vp ans;
  for (auto v : L) {
    while (i < R.end() && r[*i].fi <= l[v].fi) {
      s.insert({-r[*i].se, *i});
      ++i;
    }
    auto it = s.lower_bound({-l[v].se, 0});
    if (it != s.end()) {
      ans.eb(v, it->se);
      s.erase(it);
    }
    if (i == R.end() && s.empty()) break;
  }
  return ans;
}

list<int> s[N<<3];
bool vis[N];
int cL[N], cR[N];

void ins(int p, int l, int r, int i) {
  s[p].pb(i);
  if (l == r) return;
  int m = (l+r)>>1;
  if (cR[i] <= m) ins(p<<1, l, m, i);
  else ins(p<<1|1, m+1, r, i);
}

int adj[N], tot;
void get(int p, int L, int R, int i) {
  if (R <= cL[i]) {
    while (!s[p].empty() && r[*s[p].begin()].se <= l[i].se) {
      if (!vis[*s[p].begin()]) vis[*s[p].begin()] = 1, adj[tot++] = *s[p].begin();
      s[p].pop_front();
    }
    return;
  } else if (L > cL[i]) return;
  else {
    int m = (L + R) >> 1;
    get(p<<1, L, m, i);
    if (cL[i] > m) get(p<<1|1, m+1, R, i);
  }
}

void clr(int p, int l, int r) {
  s[p].clear();
  if (l == r) return;
  int m = (l+r)>>1;
  clr(p<<1, l, m);
  clr(p<<1|1, m+1, r);
}

pair<vi, vi> part(vi &L, vi &R) {
  static int ml[N], qu[N], hd, tl;
  static bool vl[N];
  hd = 0, tl = -1;
  // cL, cR
  vector<int> D(L.size() + R.size());
  FOR(i,0,(int)L.size()-1) D[i] = l[L[i]].fi;
  FOR(i,0,(int)R.size()-1) D[i+L.size()] = r[R[i]].fi;
  sort(begin(D), end(D));
  auto ed = unique(begin(D), end(D));
  for (auto i : L) {
    cL[i] = lower_bound(begin(D), ed, l[i].fi) - begin(D) + 1;
  }
  for (auto i : R) {
    cR[i] = lower_bound(begin(D), ed, r[i].fi) - begin(D) + 1;
  }
  int n = ed - begin(D);
  auto E = match(L, R);
  sort_y(R, r);
  for (auto i : R) ins(1,1,n,i);
  for (auto &[u, v] : E) ml[v] = u, vl[u] = 1;
  for (auto u : L) {
    if (!vl[u]) qu[++tl] = u;
    vl[u] ^= 1;
  }
  while (hd <= tl) {
    int u = qu[hd++];
    tot = 0;
    get(1,1,n,u);
    FOR(i,0,tot-1) {
      int v = ml[adj[i]];
      if (!vl[v]) vl[v] = 1, qu[++tl] = v;
    }
  }
  clr(1,1,n);
  vi lp, rp, ln, rn;
  for (auto i : L) {
    if (vl[i]) lp.pb(i);
    else ln.pb(i);
    vl[i] = 0;
  }
  for (auto i : R) {
    if (vis[i]) rp.pb(i);
    else rn.pb(i);
    vis[i] = 0;
  }
  L.swap(lp);
  R.swap(rp);
  return {ln, rn};
}

int cnt[N];
void best_match(const vi &L, vi R, int x) {
  if (L.size() - x == R.size()) {
    FOR(i,0,(int)L.size()-x-1) ++cnt[L[i]];
    return;
  }
  const int siz = L.size() - x/2;
  vi L1(L.begin(), L.begin() + siz);
  auto [L2, R2] = part(L1, R);
  int t = 0;
  if (L1.size()) {
    const int &lim = L[L.size() - x];
    while (t < L1.size() && L1[L1.size()-1-t] >= lim) ++t;
  }
  best_match(L1, R, t);
  L2.insert(L2.end(), L.begin()+siz, L.end());
  // best_match(L2, R2, x/2);
  auto [L3, R3] = part(L2, R2);
  t = 0;
  if (L2.size()) {
    const int &lim = L[siz];
    while (t < L2.size() && L2[L2.size()-1-t] >= lim) ++t;
  }
  best_match(L2, R2, t);
  for (auto i : L3) cnt[i]++;
  // for (auto i : match(L3, R3)) ++cnt[i.first];
}

inline void sol() {
  int n, m;
  rd(n);
  FOR(i,1,n) rd(r[i].fi, r[i].se);
  rd(m);
  FOR(i,1,m) rd(l[i].fi, l[i].se);
  vector<int> L(m), R(n);
  iota(begin(L), end(L), 1);
  iota(begin(R), end(R), 1);
  best_match(L, R, m);
  // for (auto [l, r] : ret) ++cnt[l];
  FOR(i,1,m) cnt[i] += cnt[i-1], O(cnt[i]);
}

int main() {
#ifndef MISAKA
#ifdef IOFILE
  freopen(IOFILE ".in", "r", stdin);
  freopen(IOFILE ".out", "w", stdout);
#endif
  ios::sync_with_stdio(0);
  cin.tie(0);
#endif
#ifdef MULTI
  int T;
  cin >> T;
  while (T--)
#endif
    sol();
  return 0;
}