#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
// --- Оптимизированное ДО ---
struct seg_tree {
struct Node {
int mx = -INF, dept = -INF;
};
vector<Node> tree;
void apply(int v, int x) {
if (x == -INF) return;
tree[v].mx = max(tree[v].mx, x);
tree[v].dept = max(tree[v].dept, x);
}
void push(int v) {
if (tree[v].dept != -INF) {
apply(2 * v, tree[v].dept);
apply(2 * v + 1, tree[v].dept);
tree[v].dept = -INF;
}
}
void change(int v, int vl, int vr, int l, int r, int x) {
if (vl >= r || vr <= l) return;
if (vl >= l && vr <= r) {
apply(v, x);
return;
}
push(v);
int m = vl + (vr - vl) / 2;
change(2 * v, vl, m, l, r, x);
change(2 * v + 1, m, vr, l, r, x);
tree[v].mx = max(tree[2 * v].mx, tree[2 * v + 1].mx);
}
int get(int v, int vl, int vr, int l, int r) {
if (vl >= r || vr <= l) return -INF;
if (vl >= l && vr <= r) return tree[v].mx;
push(v);
int m = vl + (vr - vl) / 2;
return max(get(2 * v, vl, m, l, r), get(2 * v + 1, m, vr, l, r));
}
};
// --- Фенвик с версионированием за O(1) ---
struct fenwick {
vector<int> s, timer;
int now = 0;
int current_limit = 0;
// Выделяем память ровно 1 раз
void init_capacity(int max_n) {
s.assign(max_n, -INF);
timer.assign(max_n, 0);
now = 0;
}
// "Очистка" за O(1)
void init(int limit) {
current_limit = limit;
now++;
}
void change(int i, int x) {
for (; i <= current_limit; i += i & -i) {
if (timer[i] != now) { // Если версия устарела - сбрасываем узел
timer[i] = now;
s[i] = -INF;
}
s[i] = max(s[i], x);
}
}
int get(int i) {
int res = -INF;
for (; i > 0; i -= i & -i) {
if (timer[i] == now) { // Учитываем только актуальные версии
res = max(res, s[i]);
}
}
return res;
}
};
// Глобальные структуры
vector<vector<pair<int, int>>> op, cl;
vector<int> lf, rf, tx;
vector<bool> ans;
vector<int> calc_cord; // Единый буфер для calc
fenwick t;
void calc(int l, int r) {
if (r - l <= 1) return;
int m = l + (r - l) / 2;
// Переиспользуем глобальный вектор без реаллокаций
calc_cord.clear();
for (int i = l; i < r; i++) {
calc_cord.push_back(lf[i]);
}
sort(calc_cord.begin(), calc_cord.end());
calc_cord.erase(unique(calc_cord.begin(), calc_cord.end()), calc_cord.end());
int len = calc_cord.size();
t.init(len); // O(1) очистка
int idx = len - 1;
for (int j = m - 1; j >= l; j--) {
int id = lower_bound(calc_cord.begin(), calc_cord.end(), lf[j]) - calc_cord.begin();
t.change(id + 1, rf[j]);
while (!op[j].empty() && op[j].back().first >= m) {
while (idx >= 0 && calc_cord[idx] >= j) idx--;
tx[op[j].back().second] = idx + 1;
if (t.get(idx + 1) > op[j].back().first) {
ans[op[j].back().second] = false;
}
op[j].pop_back();
}
}
t.init(len); // O(1) очистка
for (int j = m; j < r; j++) {
int id = lower_bound(calc_cord.begin(), calc_cord.end(), lf[j]) - calc_cord.begin();
t.change(id + 1, rf[j]);
while (!cl[j].empty() && cl[j].back().first < m) {
int curr_idx = tx[cl[j].back().second];
if (t.get(curr_idx) > j) {
ans[cl[j].back().second] = false;
}
cl[j].pop_back();
}
}
calc(l, m);
calc(m, r);
}
void solve() {
int n;
if (!(cin >> n)) return;
vector<int> a(n), b(n), cord;
cord.reserve(2 * n);
for (int i = 0; i < n; i++) {
cin >> a[i];
cord.push_back(a[i]);
}
for (int i = 0; i < n; i++) {
cin >> b[i];
cord.push_back(b[i]);
}
sort(cord.begin(), cord.end());
cord.resize(unique(cord.begin(), cord.end()) - cord.begin());
int m = (int)cord.size();
lf.resize(n);
seg_tree t1, t2;
t1.tree.assign(4 * m, seg_tree::Node());
t2.tree.assign(4 * m, seg_tree::Node());
for (int i = 0; i < n; i++) {
int lt = lower_bound(cord.begin(), cord.end(), b[i]) - cord.begin();
int rt = lower_bound(cord.begin(), cord.end(), a[i]) - cord.begin();
lf[i] = max(t1.get(1, 0, m, lt, rt + 1), t2.get(1, 0, m, lt, lt + 1));
t1.change(1, 0, m, lt, lt + 1, i);
t2.change(1, 0, m, lt, rt + 1, i);
}
rf.resize(n);
t1.tree.assign(4 * m, seg_tree::Node());
t2.tree.assign(4 * m, seg_tree::Node());
for (int i = n - 1; i >= 0; i--) {
int lt = lower_bound(cord.begin(), cord.end(), b[i]) - cord.begin();
int rt = lower_bound(cord.begin(), cord.end(), a[i]) - cord.begin();
rf[i] = -max(t1.get(1, 0, m, lt, rt + 1), t2.get(1, 0, m, lt, lt + 1));
t1.change(1, 0, m, lt, lt + 1, -i);
t2.change(1, 0, m, lt, rt + 1, -i);
}
op.assign(n, vector<pair<int, int>>());
cl.assign(n, vector<pair<int, int>>());
int q; cin >> q;
ans.assign(q, true);
tx.resize(q);
for (int i = 0; i < q; i++) {
int l, r; cin >> l >> r;
l--, r--;
op[l].emplace_back(r, i);
cl[r].emplace_back(l, i);
}
for (int i = 0; i < n; i++) {
sort(op[i].begin(), op[i].end());
sort(cl[i].rbegin(), cl[i].rend());
}
// Подготавливаем память перед рекурсией
calc_cord.reserve(n + 5);
t.init_capacity(n + 5);
calc(0, n);
for (int i = 0; i < q; i++) {
if (ans[i]) cout << "Yes\n";
else cout << "No\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int q = 1;
while (q--) solve();
return 0;
}
