#include <iostream>
#include <cstdio>
#include <algorithm>
#include <set>
#include <vector>
#include <map>
#include <queue>

using namespace std;

struct point{
    int x, y;
    point(){};
    point ( int x, int y ){
        this -> x = x;
        this -> y = y;
    }
};

struct rec{
    point a, b;
};

int N, Q;
rec R[1 << 17];
rec query[1 << 17];
vector < point > P;
map < pair < int, int >, int > mp;
vector < int > add[1 << 20];
vector < int > del[1 << 20];
vector < point > pts[1 << 20];
set < pair < int, int > > st;
int who[1 << 17];
vector < int > v[1 << 17];
int used[1 << 17];
priority_queue < pair < int, int > > q[1 << 22];
int isDel[1 << 17];
int jump[1 << 17][20];
int lvl[1 << 17];
int son[1 << 17];

void scan(){
    scanf ( "%d", &N );
    
    for ( int i = 0; i < N; ++i ){
        scanf ( "%d%d%d%d", &R[i].a.x, &R[i].a.y, &R[i].b.x, &R[i].b.y );
        R[i].a.x += 2; R[i].a.y += 2; R[i].b.x += 2; R[i].b.y += 2;
        P.push_back ( R[i].a );
    }
    
    
    scanf ( "%d", &Q );
    
    for ( int i = 0; i < Q; ++i ){
        scanf ( "%d%d%d%d", &query[i].a.x, &query[i].a.y, &query[i].b.x, &query[i].b.y );
        query[i].a.x += 2; query[i].a.y += 2; query[i].b.x += 2; query[i].b.y += 2;
        P.push_back ( query[i].a );
        P.push_back ( query[i].b );
    }
}

int f ( point t1, point t2 ){
    if ( t1.x == t2.x )
        return t1.y < t2.y;
    
    return t1.x < t2.x;
}

int check ( int x ){
    set < pair < int, int > > :: iterator it;
    pair < int, int > t = make_pair ( x, 1e9 );
    
    it = st.lower_bound ( t );
    
    if ( it == st.end() ){
        if ( it == st.begin() ) return -1;
        else --it;
    }
    if ( it -> first > t.first )
    --it;
    if ( R[it -> second].b.y < t.first )
        return -1;
    return it->second;
}


bool g ( rec t1, rec t2 ){
    return t1.a.x < t2.a.x;
}

int dist ( int t1, int t2 ){
    int res = 0;
    
    if ( lvl[t1] < lvl[t2] )
        swap ( t1, t2 );
    
    while ( lvl[t1] != lvl[t2] ){
        t1 = jump[t1][0];
        ++res;
    }
    
    while ( t1 != t2 ){
        t1 = jump[t1][0];
        t2 = jump[t2][0];
        res += 2;
    }
    
    return res;
    int p = 19, tt1 = t1, tt2 = t2;
    if ( t1 == t2 )
        return 0;
    while ( lvl[t1] != lvl[t2] ){
        
        while ( (1 << p ) + lvl[t2] > lvl[t1] )
            --p;
        t1 = jump[t1][p];
    }
    
    p = 19;
    
    if ( t1 == t2 ) return lvl[tt1] - lvl[tt2];
    
    while ( jump[t1][p] == 0 )
        --p;
    
    while ( p ){
        while ( jump[t1][p] == jump[t2][p] ){
            --p;
            if ( p == 0 ) break;
        }
        if ( p ){
            t1 = jump[t1][p];
            t2 = jump[t2][p];
        }
    }
    
    int lca = jump[t1][0];
    
    return lvl[tt1] + lvl[tt2] - lvl[lca] * 2;
}

void ERASE (int idx){
    isDel[idx] = 1;
}

void update ( int l, int r, int idx, int L, int RR, int val ){
    if ( l > RR || L > r )
        return;
    if ( L <= l && RR >= r ){
        q[idx].push ( make_pair ( -R[val].b.x, val ) );
        return;
    }
    
    int mid = ( l + r ) / 2;
    
    update ( l, mid, idx * 2, L, RR, val );
    update ( mid + 1, r, idx * 2 + 1, L, RR, val );
}

void ADD ( int idx ){
    update ( 1, ( 1 << 20 ), 1, R[idx].a.y, R[idx].b.y, idx );
}

inline int bigger ( int t1, int t2 ){
    if ( t1 == -1 && t2 == -1 )
        return -1;
    
    if ( t1 == -1 )
        return t2;
    if ( t2 == -1 )
        return t1;
    
    if ( R[t1].b.x < R[t2].b.x )
        return t1;
    return t2;
}

inline int bigger ( int t1, int t2, int t3 ){
    return bigger ( bigger ( t1, t2 ), t3 );
}

int find ( int l, int r, int idx, int pos ){
    if ( pos < l || pos > r )
        return -1;
    
   // cout << l << "      " << r << " " << pos << endl;
        while ( q[idx].size() ){
            if ( isDel[ q[idx].top().second ] )
                q[idx].pop();
            else
                break;
        }
    if ( l == r ){
        if ( !q[idx].size() )
            return -1;
        return q[idx].top().second;
    }
    
    int mid = ( l + r ) / 2;
    int t1 = find ( l, mid, idx * 2, pos ), t2 = find ( mid + 1, r, idx * 2 + 1, pos );
    int t3;
    if ( !q[idx].size() )
        t3 = -1;
    else
        t3 = q[idx].top().second;
    
    return bigger ( t1, t2, t3 );
    
}
int find ( int y ){
    return find ( 1, ( 1 << 20 ) , 1, y );
}

int go ( int i, int l ){
    lvl[i] = l;
    if ( l && ( l & ( -l ) ) == l ){
        int p = 0;
        while ( ( 1 << p ) != l ) ++p;
        jump[i][p] = 1;
    }
    
    
    
    for ( int j = 0; j < v[i].size(); ++j ){
        for ( int k = 0; k < 20; ++k )
            if ( jump[i][k] )
                jump[v[i][j]][k] = son[jump[i][k]];
        son[i] = v[i][j];
        go ( v[i][j], l + 1 );
    }
    
}
void solve(){
    R[N].a.x = R[N].a.y = 1;
    R[N].b.x = R[N].b.y = 1e6 + 4;
    
    P.push_back ( R[N].a );
    ++N;
    sort ( P.begin(), P.end(), f );
    sort ( R, R + N, g );
    
    for ( int i = 0; i < N; ++i ){
        add[ R[i].a.x ].push_back ( i );
        del[ R[i].b.x ].push_back ( i );
    }
    for ( int i = 0; i < (int)P.size(); ++i )
        pts[ P[i].x ].push_back ( P[i] );
    
    
    for ( int i = 0; i < ( 1 << 20 ); ++i ){
        for ( int j = 0; j < del[i].size(); ++j )
            ERASE ( del[i][j] );
        
        for ( int j = 0; j < pts[i].size(); ++j ){
            int t1 = find ( pts[i][j].y );
            mp[ make_pair ( pts[i][j].x, pts[i][j].y ) ] = t1;
     //       cout << pts[i][j].x << " " << pts[i][j].y << " " << R[t1].a.x << " " << R[t1].a.y << endl;
        }
        for ( int j = 0; j < add[i].size(); ++j )
            ADD ( add[i][j] );
        
        
    }
    int cnt = 1;
    

    for ( int i = 0; i < N; ++i ){
        int t = mp[ make_pair ( R[i].a.x, R[i].a.y ) ];
        who[i] = cnt;
        if ( t != -1 )
            v[who[t]].push_back ( cnt );
      //  if ( t != -1 ) cout << who[t] << " " << cnt << endl;
        ++cnt;
    }
    
    go ( 1, 0 );
    
   /* for ( int i = 1; i <= cnt; ++i ){
        for ( int j = 0; j < 10; ++j )
            cout << jump[i][j] << " ";
        cout << endl;
    }*/
        
    for ( int i = 0; i < Q; ++i ){
        int t1 = mp[ make_pair ( query[i].a.x, query[i].a.y ) ], t2 = mp[ make_pair ( query[i].b.x, query[i].b.y ) ];
        t1 = who[t1];
        t2 = who[t2];
       // cout << t1 << " " << t2 << endl;
     //   cout << query[i].a.x << " " << query[i].a.y << endl;
        printf ( "%d\n", dist ( t1, t2 ) );
    }

    /*
    for ( int i = 0; i < ( 1 << 20 ); ++i ){
        for ( int j = 0; j < (int)pts[i].size(); ++j )
            mp[ make_pair ( pts[i][j].x, pts[i][j].y ) ] = check ( pts[i][j].y );
            
        for ( int j = 0; j < (int)add[i].size(); ++j ){
            addSeg ( add[i][j] );
            cout << i << " " << add[i][j] << "\n";
        }
        for ( int j = 0; j < (int)del[i].size(); ++j ){
            delSeg ( del[i][j] );
            cout << i << "-" << del[i][j] << "\n";
        }
    }
    
    for ( map < pair < int, int >, int > :: iterator i = mp.begin(); i != mp.end(); ++i )
        cout << ( i -> first.first ) << " " << ( i -> first.second ) << " " << ( i -> second ) << endl;
        */
}

int main(){
    scan();
    solve();
}