#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


//      k[0]    k[1]  ...       k[n-1]=kLim
// ------)[------)[-  ...  -)[------)[unpainted
//  v[0]    v[1]              v[n-1]
template <class K, class V> struct Painter : map<K, V> {
  const K kLim;
  Painter(K k, const V &v) : map<K, V>{{k, v}}, kLim(k) {}
  // Paint [a, b) with v, calling f(left, right, (old color)).
  template <class F> void paint(K a, K b, const V &v, F f) {
    assert(a < b); assert(b < kLim);
    auto it = this->lower_bound(a);
    if (b < it->first) {
      f(a, b, it->second);
      this->emplace(a, it->second);
      this->emplace(b, v);
    } else if (a < it->first) {
      const V va = it->second;
      K k = a;
      for (; it->first <= b; it = this->erase(it)) {
        f(k, it->first, it->second);
        k = it->first;
      }
      if (k < b) {
        f(k, b, it->second);
      }
      this->emplace(a, va);
      this->emplace(b, v);
    } else {
      ++it;
      K k = a;
      for (; it->first <= b; it = this->erase(it)) {
        f(k, it->first, it->second);
        k = it->first;
      }
      if (k < b) {
        f(k, b, it->second);
      }
      this->emplace(b, v);
    }
  }
  void paint(K a, K b, const V &v) {
    paint(a, b, v, [&](K, K, const V &) -> void {});
  }
  V get(K k) const {
    assert(k < kLim);
    return this->upper_bound(k)->second;
  }
};

////////////////////////////////////////////////////////////////////////////////


template <class X, class Y, class T> struct StaticRectAddPointSum {
  struct Rect {
    X x0, x1;
    Y y0, y1;
  };
  vector<Rect> as;
  vector<pair<X, Y>> bs;
  vector<T> vals, anss;
  // Adds val to [x0, x1) [y0, y1).
  //   ~~> Adds to (x*, y*)
  void add(X x0, X x1, Y y0, Y y1, const T &val) {
    assert(x0 <= x1); assert(y0 <= y1);
    as.push_back(Rect{x0, x1, y0, y1});
    vals.push_back(val);
  }
  // Gets sum at (x, y).
  void get(X x, Y y) {
    bs.emplace_back(x, y);
  }

  void run() {
    const int asLen = as.size(), bsLen = bs.size();

    // same x ==> add then get
    vector<pair<X, int>> events((asLen << 1) + bsLen);
    for (int i = 0; i < asLen; ++i) {
      events[i << 1    ] = std::make_pair(as[i].x0, i << 1    );
      events[i << 1 | 1] = std::make_pair(as[i].x1, i << 1 | 1);
    }
    for (int j = 0; j < bsLen; ++j) {
      events[(asLen << 1) + j] = std::make_pair(bs[j].first, (asLen << 1) + j);
    }
    std::sort(events.begin(), events.end());

    vector<Y> ys(bsLen);
    for (int j = 0; j < bsLen; ++j) {
      ys[j] = bs[j].second;
    }
    std::sort(ys.begin(), ys.end());
    ys.erase(std::unique(ys.begin(), ys.end()), ys.end());
    const int ysLen = ys.size();
    vector<T> bit(ysLen, 0);

    anss.assign(bsLen, 0);
    for (const auto &event : events) {
      if (event.second >= asLen << 1) {
        const int j = event.second - (asLen << 1);
        T sum = 0;
        for (int l = std::lower_bound(ys.begin(), ys.end(), bs[j].second) - ys.begin() + 1; l > 0; l &= l - 1) {
          sum += bit[l - 1];
        }
        anss[j] = sum;
      } else {
        const int i = event.second >> 1;
        const T val = (event.second & 1) ? -vals[i] : vals[i];
        for (int l = std::lower_bound(ys.begin(), ys.end(), as[i].y0) - ys.begin(); l < ysLen; l |= l + 1) {
          bit[l] += val;
        }
        for (int l = std::lower_bound(ys.begin(), ys.end(), as[i].y1) - ys.begin(); l < ysLen; l |= l + 1) {
          bit[l] -= val;
        }
      }
    }
  }
};

////////////////////////////////////////////////////////////////////////////////


/*
  Hall
  -> "No" <=> \exists isolated interval
*/

int N;
vector<int> A, B;
int Q;
vector<int> L, R;

vector<int> getHits() {
  vector<int> ls(N, -1);
  Painter<int, int> pa(2 * N + 1, -1);
  for (int i = 0; i < N; ++i) {
    pa.paint(B[i], A[i], i, [&](int b, int a, int old) -> void {
      chmax(ls[i], old);
    });
  }
  return ls;
}

int main() {
  for (; ~scanf("%d", &N); ) {
    A.resize(N); for (int i = 0; i < N; ++i) scanf("%d", &A[i]);
    B.resize(N); for (int i = 0; i < N; ++i) scanf("%d", &B[i]);
    scanf("%d", &Q);
    L.resize(Q);
    R.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d", &L[q], &R[q]);
      --L[q];
    }
    
    auto ls = getHits();
    reverse(A.begin(), A.end());
    reverse(B.begin(), B.end());
    auto rs = getHits();
    reverse(rs.begin(), rs.end());
    for (int i = 0; i < N; ++i) rs[i] = N - 1 - rs[i];
    reverse(A.begin(), A.end());
    reverse(B.begin(), B.end());
// cerr<<"ls = "<<ls<<endl;
// cerr<<"rs = "<<rs<<endl;
    
    StaticRectAddPointSum<int, int, int> f;
    for (int i = 0; i < N; ++i) {
      // ls[i] < l <= i < r <= rs[i]
      f.add(ls[i] + 1, i + 1, i + 1, rs[i] + 1, 1);
    }
    for (int q = 0; q < Q; ++q) {
      f.get(L[q], R[q]);
    }
    f.run();
    for (int q = 0; q < Q; ++q) {
      puts(f.anss[q] ? "No" : "Yes");
    }
  }
  return 0;
}