#include <bits/stdc++.h>

#define rep( i, a, b ) for( int i = (a) ; i <= (b) ; i ++ )
#define per( i, a, b ) for( int i = (a) ; i >= (b) ; i -- )

const int MAXN = 2e5 + 10;

template<typename _T>
inline void Read( _T &x ) {
    x = 0; char s = getchar(); bool f = false;
    while( s < '0' || '9' < s ) { f = s == '-', s = getchar(); }
    while( '0' <= s && s <= '9' ) { x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar(); }
    if( f ) x = -x;
}

template<typename _T>
inline void Write( _T x ) {
    if( x < 0 ) putchar( '-' ), x = -x;
    if( 9 < x ) Write( x / 10 );
    putchar( x % 10 + '0' );
}

typedef std :: pair<int, int> Point;

std :: set<std :: pair<int, int> > s;
int BIT[MAXN], succ[MAXN];

Point pnt[MAXN];
int buf[MAXN];

int ans[MAXN];

int N, M;

inline void Down( int &x ) { x &= x - 1; }
inline void Up( int &x ) { x += x & ( - x ); }
inline void Update( int x, int v ) { for( ; x <= M ; Up( x ) ) BIT[x] += v; }
inline  int Query( int x ) { int ret = 0; for( ; x ; Down( x ) ) ret += BIT[x]; return ret; }

void Divide( const std :: vector<int> &blk, const std :: vector<int> &wht,
             const int &wL, const int &wR, const int &su ) {
    if( wL > wR ) return ;
    int n = blk.size(), m = wht.size();
    int mid = ( wL + wR ) >> 1, tot = 0;
    rep( i, 0, n - 1 ) buf[++ tot] = blk[i];
    rep( i, 0, m - 1 ) 
        if( wht[i] <= N + mid )
            buf[++ tot] = wht[i];
    std :: sort( buf + 1, buf + 1 + tot,
        [] ( const int &a, const int &b ) -> bool {
            return pnt[a] == pnt[b] ? a < b : pnt[a] < pnt[b];
        } );

    s.clear();
    per( i, tot, 1 ) {
        int cur = buf[i]; succ[cur] = 0;
        if( cur > N ) {
            auto it = s.upper_bound( { pnt[cur].second, N + M + 1 } );
            if( it != s.begin() ) succ[cur] = ( -- it ) -> second;
            s.insert( { pnt[cur].second, cur } );
        } else {
            auto it = s.lower_bound( { pnt[cur].second, 0 } );
            if( it != s.end() ) s.erase( it );
        }
    }
    std :: vector<Point> stk;
    if( ! s.empty() )
        for( int x = s.rbegin() -> second ; x ; x = succ[x] )
            stk.push_back( pnt[x] );
    // std :: vector<Point> stk;
    // for( auto it = s.rbegin() ; it != s.rend() ; it ++ )
    //     if( stk.empty() || stk.back().first < it -> second )
    //         stk.push_back( { it -> second, it -> first } );

    std :: vector<int> blkL, blkR, whtL, whtR;
    for( const int &cur : blk ) {
        auto it = std :: lower_bound( stk.begin(), stk.end(), Point( pnt[cur].first, 0 ) );
        if( it != stk.end() && it -> second >= pnt[cur].second )
            blkL.push_back( cur );
        else blkR.push_back( cur );
    }
    for( const int &cur : wht ) {
        auto it = std :: lower_bound( stk.begin(), stk.end(), Point( pnt[cur].first, 0 ) );
        if( it != stk.end() && it -> second >= pnt[cur].second )
            whtL.push_back( cur );
        else whtR.push_back( cur );
    }
    Divide( blkL, whtL, wL, mid - 1, su );
    for( const int &x : whtL ) Update( x - N, +1 );
    ans[mid] = su - blkL.size() + Query( mid );
    Divide( blkR, whtR, mid + 1, wR, su - blkL.size() );
    for( const int &x : whtL ) Update( x - N, -1 );
}

int main() {
    // freopen( "insect.in", "r", stdin );
    // freopen( "insect.out", "w", stdout );
    Read( N );
    rep( i, 1, N )
        Read( pnt[i].first ), Read( pnt[i].second );
    Read( M );
    rep( i, 1, M )
        Read( pnt[i + N].first ), Read( pnt[i + N].second );
    std :: vector<int> blk( N ), wht( M );
    rep( i, 1, N ) blk[i - 1] = i;
    rep( i, 1, M ) wht[i - 1] = i + N;
    Divide( blk, wht, 1, M, 0 );
    rep( i, 1, M ) Write( i - ans[i] ), putchar( '\n' );
    return 0;
}