// author: hotman78
// date: 2023/03/10-22:57:20

// --- begin raw code -----------------
// #include"cpplib/util/template.hpp"
// 
// int main(){
//     int n;
//     cin>>n;
//     vector<int> h(n),t(n);
//     rep(i,n)cin>>h[i];
//     rep(i,n)cin>>t[i];
//     int q;
//     cin>>q;
//     vector<tuple<int,int,int>>v(n);
//     vector<int> v2(n);
//     {
//         rep(i,n)v[i]=make_tuple(h[i],-t[i],i);
//         int cnt=-1,idx=-1;
//         sort(all(v));
//         rep(i,n){
//             if(chmax(cnt,-get<1>(v[i])))idx=get<2>(v[i]);
//             v2[i]=idx;
//         }
// 
//     }
//     vector<vector<int>> tb(30,vector<int>(n));
//     rep(i,n){
//         int idx=lower_bound(all(v),make_tuple(t[i],IINF,IINF))-v.begin()-1;
//         if(idx==-1)tb[0][i]=i;
//         else tb[0][i]=v2[idx];
//     }
//     rep(j,29){
//         rep(i,n){
//             tb[j+1][i]=tb[j][tb[j][i]];
//         }
//     }
//     auto get=[&](int x,int fst)->int
//     {
//         int cnt=0,res=fst;
//         while(x){
//             if(x%2){
//                 res=tb[cnt][res];
//             }
//             x/=2;
//             cnt++;
//         }
//         return res;  
//     };
//     while(q--){
//         int p,q;
//         cin>>p>>q;
//         p--;q--;
//         if(t[p]>=h[q]){
//                 cout<<1<<endl;
//         }else{
//             int ng=0,ok=1LL<<20;
//             while(ok-ng>1){
//                 lint m=(ok+ng)/2;
//                 if(t[get(m,p)]>=h[q]){
//                     ok=m;
//                 }else{
//                     ng=m;
//                 }
//             }
//             if(ok>=1LL<<19){
//                 ok=-2;
//             }
//             cout<<ok+1<<endl;
//         }
//     }
// }
// --- end raw code -----------------

#line 2 "cpplib/util/template.hpp"
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;
#line 1 "cpplib/util/ioutil.hpp"
// template <class Head,class... Args>
// std::ostream& output(std::ostream& out,const Head& head,const Args&... args){
//     out>>head;
//     return output(head,args...);
// }
// template <class Head>
// std::ostream& output(std::ostream& out,const Head& head){
//     out>>head;
//     return out;
// }

template <typename T, typename E>
std::ostream &operator<<(std::ostream &out, std::pair<T, E> v) {
    out << "(" << v.first << "," << v.second << ")";
    return out;
}

// template <class... Args>
// ostream& operator<<(ostream& out,std::tuple<Args...>v){
//     std::apply(output,v);
//     return out;
// }
#line 8 "cpplib/util/template.hpp"
struct __INIT__ {
    __INIT__() {
        cin.tie(0);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(15);
    }
} __INIT__;
typedef long long lint;
constexpr long long INF = 1LL << 60;
constexpr int IINF = 1 << 30;
constexpr double EPS = 1e-10;
#ifndef REACTIVE
#define endl '\n';
#endif
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
template <typename T> inline void output(T t) {
    bool f = 0;
    for (auto i : t) {
        cout << (f ? " " : "") << i;
        f = 1;
    }
    cout << endl;
}
template <typename T> inline void output2(T t) {
    for (auto i : t)
        output(i);
}
template <typename T> inline void debug(T t) {
    bool f = 0;
    for (auto i : t) {
        cerr << (f ? " " : "") << i;
        f = 1;
    }
    cerr << endl;
}
template <typename T> inline void debug2(T t) {
    for (auto i : t)
        debug(i);
}
#define loop(n) for (long long _ = 0; _ < (long long)(n); ++_)
#define _overload4(_1, _2, _3, _4, name, ...) name
#define __rep(i, a) repi(i, 0, a, 1)
#define _rep(i, a, b) repi(i, a, b, 1)
#define repi(i, a, b, c)                                                       \
    for (long long i = (long long)(a); i < (long long)(b); i += c)
#define rep(...) _overload4(__VA_ARGS__, repi, _rep, __rep)(__VA_ARGS__)
#define _overload3_rev(_1, _2, _3, name, ...) name
#define _rep_rev(i, a) repi_rev(i, 0, a)
#define repi_rev(i, a, b)                                                      \
    for (long long i = (long long)(b)-1; i >= (long long)(a); --i)
#define rrep(...) _overload3_rev(__VA_ARGS__, repi_rev, _rep_rev)(__VA_ARGS__)

#define all(n) begin(n), end(n)
template <typename T, typename E> bool chmin(T &s, const E &t) {
    bool res = s > t;
    s = min<T>(s, t);
    return res;
}
template <typename T, typename E> bool chmax(T &s, const E &t) {
    bool res = s < t;
    s = max<T>(s, t);
    return res;
}
const vector<lint> dx = {1, 0, -1, 0, 1, 1, -1, -1};
const vector<lint> dy = {0, 1, 0, -1, 1, -1, 1, -1};
#define SUM(v) accumulate(all(v), 0LL)
#if __cplusplus >= 201703L
template <typename T, typename... Args>
auto make_vector(T x, int arg, Args... args) {
    if constexpr (sizeof...(args) == 0)
        return vector<T>(arg, x);
    else
        return vector(arg, make_vector<T>(x, args...));
}
#endif
#define extrep(v, ...) for (auto v : __MAKE_MAT__({__VA_ARGS__}))
#define bit(n, a) ((n >> a) & 1)
vector<vector<long long>> __MAKE_MAT__(vector<long long> v) {
    if (v.empty())
        return vector<vector<long long>>(1, vector<long long>());
    long long n = v.back();
    v.pop_back();
    vector<vector<long long>> ret;
    vector<vector<long long>> tmp = __MAKE_MAT__(v);
    for (auto e : tmp)
        for (long long i = 0; i < n; ++i) {
            ret.push_back(e);
            ret.back().push_back(i);
        }
    return ret;
}
using graph = vector<vector<int>>;
template <typename T> using graph_w = vector<vector<pair<int, T>>>;

#if __cplusplus >= 201703L
constexpr inline long long powll(long long a, long long b) {
    long long res = 1;
    while (b--)
        res *= a;
    return res;
}
#endif

template <typename T, typename E>
pair<T, E> &operator+=(pair<T, E> &s, const pair<T, E> &t) {
    s.first += t.first;
    s.second += t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> &operator-=(pair<T, E> &s, const pair<T, E> &t) {
    s.first -= t.first;
    s.second -= t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> operator+(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res += t;
}
template <typename T, typename E>
pair<T, E> operator-(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res -= t;
}
#define BEGIN_STACK_EXTEND(size)                                               \
    void *stack_extend_memory_ = malloc(size);                                 \
    void *stack_extend_origin_memory_;                                         \
    char *stack_extend_dummy_memory_ = (char *)alloca(                         \
        (1 + (int)(((long long)stack_extend_memory_) & 127)) * 16);            \
    *stack_extend_dummy_memory_ = 0;                                           \
    asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp"                          \
                 : "=b"(stack_extend_origin_memory_)                           \
                 : "a"((char *)stack_extend_memory_ + (size)-1024));
#define END_STACK_EXTEND                                                       \
    asm volatile("mov %%rax, %%rsp" ::"a"(stack_extend_origin_memory_));       \
    free(stack_extend_memory_);
#line 2 "main.cpp"

int main() {
    int n;
    cin >> n;
    vector<int> h(n), t(n);
    rep(i, n) cin >> h[i];
    rep(i, n) cin >> t[i];
    int q;
    cin >> q;
    vector<tuple<int, int, int>> v(n);
    vector<int> v2(n);
    {
        rep(i, n) v[i] = make_tuple(h[i], -t[i], i);
        int cnt = -1, idx = -1;
        sort(all(v));
        rep(i, n) {
            if (chmax(cnt, -get<1>(v[i])))
                idx = get<2>(v[i]);
            v2[i] = idx;
        }
    }
    vector<vector<int>> tb(30, vector<int>(n));
    rep(i, n) {
        int idx =
            lower_bound(all(v), make_tuple(t[i], IINF, IINF)) - v.begin() - 1;
        if (idx == -1)
            tb[0][i] = i;
        else
            tb[0][i] = v2[idx];
    }
    rep(j, 29) {
        rep(i, n) { tb[j + 1][i] = tb[j][tb[j][i]]; }
    }
    auto get = [&](int x, int fst) -> int {
        int cnt = 0, res = fst;
        while (x) {
            if (x % 2) {
                res = tb[cnt][res];
            }
            x /= 2;
            cnt++;
        }
        return res;
    };
    while (q--) {
        int p, q;
        cin >> p >> q;
        p--;
        q--;
        if (t[p] >= h[q]) {
            cout << 1 << endl;
        } else {
            int ng = 0, ok = 1LL << 20;
            while (ok - ng > 1) {
                lint m = (ok + ng) / 2;
                if (t[get(m, p)] >= h[q]) {
                    ok = m;
                } else {
                    ng = m;
                }
            }
            if (ok >= 1LL << 19) {
                ok = -2;
            }
            cout << ok + 1 << endl;
        }
    }
}