#include <cstdio>
#include <vector>

constexpr int MAXN = 200000 + 2;
constexpr int MAXM = MAXN * 3;
constexpr int MAXQ = MAXN * 5;
constexpr int HASH_P[2] = {1000000993, 1000000933};
constexpr int HASH_BASE[2] = {783763, 997991};
constexpr int SQRT_HASH_P = 31623;

template <int B, int P> class QuickPower {
public:
    int big[SQRT_HASH_P], small[SQRT_HASH_P];

    QuickPower() {
        big[0] = small[0] = 1;
        for (int i = 1; i < SQRT_HASH_P; i ++) {
            small[i] = (long long){small[i - 1]} * B % P;
        }
        for (int i = 1, b = small[SQRT_HASH_P - 1]; i < SQRT_HASH_P; i ++) {
            big[i] = (long long){big[i - 1]} * b % P;
        }
    }

    int operator ()(int x) const {
        return (long long){big[x / SQRT_HASH_P]} * small[x % SQRT_HASH_P] % P;
    }
};

template <int _type> class Hash {
public:
    static QuickPower<HASH_BASE[_type], HASH_P[_type]> pw;

    int val;

    template <int _t> Hash& operator +=(const Hash<_t> &rhs) {
        val = (val + pw(rhs.val)) % HASH_P[_type];
        return *this;
    }

    template <int _t> Hash& operator -=(const Hash<_t> &rhs) {
        val = (val + HASH_P[_type] - pw(rhs.val)) % HASH_P[_type];
        return *this;
    }

    bool operator !=(const Hash &rhs) {
        return val != rhs.val;
    }
};

template <int _type> QuickPower<HASH_BASE[_type], HASH_P[_type]> Hash<_type>::pw;

Hash<0> ph[MAXM][2];
Hash<1> th[2];

int a[MAXM], b[MAXM];
bool ans[MAXQ];

std::vector<std::pair<int, int>> qry[MAXN];

void remove(int v, int x, int o) {
    th[o] -= ph[v][o];
    ph[v][o] -= Hash<0>{x};
    th[o] += ph[v][o];
}

void insert(int v, int x, int o) {
    th[o] -= ph[v][o];
    ph[v][o] += Hash<0>{x};
    th[o] += ph[v][o];
}

int main() {
    int n, m, q;
    scanf("%d%d%d", &n, &m, &q);

    for (int i = 1; i <= n * 3; i ++) {
        scanf("%d", &a[i]);
    }
    for (int i = 1; i <= n * 3; i ++) {
        scanf("%d", &b[i]);
    }
    for (int i = 0, l, r; i < q; i ++) {
        scanf("%d%d", &l, &r);
        qry[r].push_back({l, i});
    }

    for (int l = 1, r = 1; r <= n; r ++) {
        for (int i = 0; i < 3; i ++) {
            insert(a[r * 3 - i], r, 0);
            insert(b[r * 3 - i], r, 1);
        }

        while (th[0] != th[1]) {
            for (int i = 0; i < 3; i ++) {
                remove(a[l * 3 - i], l, 0);
                remove(b[l * 3 - i], l, 1);
            }
            l ++;
        }

        for (auto pr : qry[r]) {
            ans[pr.second] = pr.first >= l;
        }
    }

    for (int i = 0; i < q; i ++) {
        puts(ans[i] ? "Yes" : "No");
    }

    return 0;
}