#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define int ll

mt19937 rnd(time(NULL));

struct Modular {
    int mod;
    Modular() = default;
    Modular(int md) {
        mod = md;
    }
    
    int sum(int x, int y) { return (x + y >= mod ? x + y - mod : x + y); }
    int diff(int x, int y) { return (x - y < 0 ? x - y + mod : x - y); }
    int mul(int x, int y) { return (x * y) % mod; }
    int binpow(int x, int y) {
        int ans = 1, pw = x;
        while (y) {
            if (y & 1) { ans = mul(ans, pw); }
            pw = mul(pw, pw);
            y >>= 1;
        }
        return ans;
    }
    int rev(int x) { return binpow(x, mod - 2); }
    int divide(int x, int y) { return mul(x, rev(y)); }
};

int sma[600010], smb[600010];

struct Hash {
    int n, m, mod;
    Modular M;

    vector<int> a, b, rval;
    int ha = 1, hb = 1, wsa, wsb;
    Hash() = default;
    Hash(int md, int n_, int m_, vector<int> a_, vector<int> b_) {
        n=n_;m=m_;mod=md;a=a_;b=b_;
        M = Modular(mod);
        rval.assign(n, 0);
        for (int i = 0; i < n; i++) rval[i] = rnd() % mod;
    }

    void add(int pos) {
        wsa = ha;
        wsb = hb;
        for (int j = 3 * pos; j < 3 * pos + 3; j++) {
            ha = M.divide(ha, max(sma[a[j]], 1ll));
            hb = M.divide(hb, max(smb[b[j]], 1ll));
            sma[a[j]] = M.sum(sma[a[j]], rval[pos]);
            smb[b[j]] = M.sum(smb[b[j]], rval[pos]);
            ha = M.mul(ha, max(sma[a[j]], 1ll));
            hb = M.mul(hb, max(smb[b[j]], 1ll));
        }
    }

    void undo(int pos) {
        ha = wsa; hb = wsb;
        for (int j = 3 * pos; j < 3 * pos + 3; j++) {
            sma[a[j]] = M.diff(sma[a[j]], rval[pos]);
            smb[b[j]] = M.diff(smb[b[j]], rval[pos]);
        }
    }

    void del(int pos) {
        for (int j = 3 * pos; j < 3 * pos + 3; j++) {
            ha = M.divide(ha, max(sma[a[j]], 1ll));
            hb = M.divide(hb, max(smb[b[j]], 1ll));
            sma[a[j]] = M.diff(sma[a[j]], rval[pos]);
            smb[b[j]] = M.diff(smb[b[j]], rval[pos]);
            ha = M.mul(ha, max(sma[a[j]], 1ll));
            hb = M.mul(hb, max(smb[b[j]], 1ll));
        }
    }

    bool check() {
        return ha == hb;
    }
};

signed main() {
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
    #endif
    cin.tie(nullptr)->sync_with_stdio(false);

    int n, m, q; cin >> n >> m >> q;
    vector<int> a(3 * n), b(3 * n);
    for (int i = 0; i < 3 * n; i++) {cin >> a[i]; a[i]--; }
    for (int &el : b) {cin >> el; el--;}

    int md1 = 1e9 + 7, md2 = 1e9 + 9;
    Hash h1(md1, n, m, a, b);
    int curr = -1;
    vector<int> maxr(n);

    for (int l = 0; l < n; l++) {
        while (curr + 1 < n) {
            h1.add(curr + 1);
            if (h1.check()) {
                curr++;
                continue;
            } else {
                h1.undo(curr + 1);
                break;
            }
        }
        maxr[l] = curr;
        if (curr >= l) {
            h1.del(l);
        }
        else {
            curr = l;
        }
    }

    h1 = Hash(md2, n, m, a, b);
    for (int l = 0; l < n; l++) {
        while (curr + 1 < n) {
            h1.add(curr + 1);
            if (h1.check()) {
                curr++;
                continue;
            } else {
                h1.undo(curr + 1);
                break;
            }
        }
        maxr[l] = min(maxr[l], curr);
        if (curr >= l) {
            h1.del(l);
        }
        else {
            curr = l;
        }
    }

    while (q--) {
        int l, r; cin >> l >> r;
        l--; r--;
        cout << (maxr[l] >= r ? "Yes\n" : "No\n");
    }
}